sig
module Std :
sig
module Integer :
sig
module type Base =
sig
type t
val zero : Bap.Std.Integer.Base.t
val one : Bap.Std.Integer.Base.t
val succ : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val pred : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val abs : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val neg : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val add :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val sub :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val mul :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val div :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val modulo :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val lnot : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val logand :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val logor :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val logxor :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val lshift :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val rshift :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
val arshift :
Bap.Std.Integer.Base.t ->
Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
end
module type S =
sig
type t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( + ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( - ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( * ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( / ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( mod ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( land ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( lor ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( lxor ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( lsl ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( lsr ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
val ( asr ) :
Bap.Std.Integer.S.t ->
Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
end
module Make :
functor (T : Base) ->
sig
type t = T.t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
end
module Legacy :
sig
module Monad :
sig
module type Basic = Core_kernel.Std.Monad.Basic
module type Basic2 = Core_kernel.Std.Monad.Basic2
module type Infix = Core_kernel.Std.Monad.Infix
module type Infix2 = Core_kernel.Std.Monad.Infix2
module type S = Core_kernel.Std.Monad.S
module type S2 = Core_kernel.Std.Monad.S2
module Make :
functor (M : Basic) ->
sig
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
module Monad_infix :
sig
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
end
val bind : 'a M.t -> f:('a -> 'b M.t) -> 'b M.t
val return : 'a -> 'a M.t
val map : 'a M.t -> f:('a -> 'b) -> 'b M.t
val join : 'a M.t M.t -> 'a M.t
val ignore_m : 'a M.t -> unit M.t
val all : 'a M.t list -> 'a list M.t
val all_ignore : unit M.t list -> unit M.t
module Let_syntax :
sig
val return : 'a -> 'a M.t
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
module Let_syntax :
sig
val return : 'a -> 'a M.t
val bind : 'a M.t -> f:('a -> 'b M.t) -> 'b M.t
val map : 'a M.t -> f:('a -> 'b) -> 'b M.t
val both : 'a M.t -> 'b M.t -> ('a * 'b) M.t
module Open_on_rhs : sig end
end
end
end
module Make2 :
functor (M : Basic2) ->
sig
val ( >>= ) :
('a, 'e) M.t -> ('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) : ('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) M.t
val ( >>= ) :
('a, 'e) M.t ->
('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) :
('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) M.t
val bind :
('a, 'e) M.t ->
f:('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val map :
('a, 'e) M.t -> f:('a -> 'b) -> ('b, 'e) M.t
val both :
('a, 'e) M.t ->
('b, 'e) M.t -> ('a * 'b, 'e) M.t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) M.t ->
('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) :
('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
end
val bind :
('a, 'e) M.t -> f:('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val return : 'a -> ('a, 'b) M.t
val map : ('a, 'e) M.t -> f:('a -> 'b) -> ('b, 'e) M.t
val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
val ignore_m : ('a, 'e) M.t -> (unit, 'e) M.t
val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
val all_ignore : (unit, 'e) M.t list -> (unit, 'e) M.t
end
module State :
sig
module type S =
sig
type ('a, 's) t
type 'a result
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
val put :
's -> (unit, 's) Bap.Std.Legacy.Monad.State.S.t
val get :
unit -> ('s, 's) Bap.Std.Legacy.Monad.State.S.t
val gets :
('s -> 'r) -> ('r, 's) Bap.Std.Legacy.Monad.State.S.t
val update :
('s -> 's) ->
(unit, 's) Bap.Std.Legacy.Monad.State.S.t
val modify :
('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
('s -> 's) -> ('a, 's) Bap.Std.Legacy.Monad.State.S.t
val run :
('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
's -> ('a * 's) Bap.Std.Legacy.Monad.State.S.result
val eval :
('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
's -> 'a Bap.Std.Legacy.Monad.State.S.result
val exec :
('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
's -> 's Bap.Std.Legacy.Monad.State.S.result
end
type ('a, 'e) t = ('a, 'e) Monads.Std.Monad.State.t
type 'a result = 'a
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
val put : 's -> (unit, 's) t
val get : unit -> ('s, 's) t
val gets : ('s -> 'r) -> ('r, 's) t
val update : ('s -> 's) -> (unit, 's) t
val modify : ('a, 's) t -> ('s -> 's) -> ('a, 's) t
val run : ('a, 's) t -> 's -> 'a * 's
val eval : ('a, 's) t -> 's -> 'a
val exec : ('a, 's) t -> 's -> 's
end
module T :
sig
module Option :
sig
module Make :
functor (M : S) ->
sig
type 'a t = 'a option M.t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_ignore : unit t list -> unit t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
end
module Make2 :
functor (M : S2) ->
sig
type ('a, 'b) t = ('a option, 'b) M.t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t ->
('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t ->
f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t ->
('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t ->
('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(unit, 'e) t list -> (unit, 'e) t
end
end
module Or_error :
sig
module Make :
functor (M : S) ->
sig
type 'a t = 'a Core_kernel.Std.Or_error.t M.t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_ignore : unit t list -> unit t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
end
module Make2 :
functor (M : S2) ->
sig
type ('a, 'b) t =
('a Core_kernel.Std.Or_error.t, 'b) M.t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t ->
('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t ->
f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t ->
('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t ->
('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(unit, 'e) t list -> (unit, 'e) t
end
end
module Result :
sig
module Make :
functor (M : S) ->
sig
type ('a, 'e) t =
('a, 'e) Core_kernel.Std.Result.t M.t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t ->
('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t ->
f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t ->
('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t ->
('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(unit, 'e) t list -> (unit, 'e) t
end
end
module State :
sig
module Make :
functor (M : S) ->
sig
type ('a, 's) t
type 'a result = 'a M.t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t ->
('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t ->
f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t ->
('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t ->
('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(unit, 'e) t list -> (unit, 'e) t
val put : 's -> (unit, 's) t
val get : unit -> ('s, 's) t
val gets : ('s -> 'r) -> ('r, 's) t
val update : ('s -> 's) -> (unit, 's) t
val modify :
('a, 's) t -> ('s -> 's) -> ('a, 's) t
val run : ('a, 's) t -> 's -> ('a * 's) result
val eval : ('a, 's) t -> 's -> 'a result
val exec : ('a, 's) t -> 's -> 's result
end
end
end
end
end
module Seq :
sig
type 'a t = 'a Core_kernel.Std.Sequence.t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
module Merge_with_duplicates_element :
sig
type ('a, 'b) t =
('a, 'b) Base.Sequence.Merge_with_duplicates_element.t =
Left of 'a
| Right of 'b
| Both of 'a * 'b
val bin_t :
'a Bin_prot.Type_class.t ->
'b Bin_prot.Type_class.t -> ('a, 'b) t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'b Bin_prot.Read.reader -> ('a, 'b) t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
'b Bin_prot.Read.reader ->
(int -> ('a, 'b) t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'b Bin_prot.Type_class.reader ->
('a, 'b) t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'b Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'b Bin_prot.Write.writer -> ('a, 'b) t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'b Bin_prot.Type_class.writer ->
('a, 'b) t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t -> Bin_prot.Shape.t
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
(Base__.Sexplib.Sexp.t -> 'b) ->
Base__.Sexplib.Sexp.t -> ('a, 'b) t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
('b -> Base__.Sexplib.Sexp.t) ->
('a, 'b) t -> Base__.Sexplib.Sexp.t
val hash_fold_t :
(Base__.Ppx_hash_lib.Std.Hash.state ->
'a -> Base__.Ppx_hash_lib.Std.Hash.state) ->
(Base__.Ppx_hash_lib.Std.Hash.state ->
'b -> Base__.Ppx_hash_lib.Std.Hash.state) ->
Base__.Ppx_hash_lib.Std.Hash.state ->
('a, 'b) t -> Base__.Ppx_hash_lib.Std.Hash.state
val compare :
('a -> 'a -> int) ->
('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
end
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) -> 'a t -> Base__.Sexplib.Sexp.t
type 'a sequence = 'a t
val mem : 'a sequence -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a sequence -> int
val iter : 'a sequence -> f:('a -> unit) -> unit
val fold :
'a sequence ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a sequence ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a sequence ->
init:'accum ->
f:('accum ->
'a -> ('accum, 'stop) Base__.Container_intf.Continue_or_stop.t) ->
('accum, 'stop) Base__.Container_intf.Finished_or_stopped_early.t
val exists : 'a sequence -> f:('a -> bool) -> bool
val for_all : 'a sequence -> f:('a -> bool) -> bool
val count : 'a sequence -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a sequence -> f:('a -> 'sum) -> 'sum
val find : 'a sequence -> f:('a -> bool) -> 'a option
val find_map : 'a sequence -> f:('a -> 'b option) -> 'b option
val to_array : 'a sequence -> 'a array
val min_elt : 'a sequence -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a sequence -> cmp:('a -> 'a -> int) -> 'a option
val ( >>= ) : 'a sequence -> ('a -> 'b sequence) -> 'b sequence
val ( >>| ) : 'a sequence -> ('a -> 'b) -> 'b sequence
module Monad_infix :
sig
val ( >>= ) :
'a Base__Sequence.t ->
('a -> 'b Base__Sequence.t) -> 'b Base__Sequence.t
val ( >>| ) :
'a Base__Sequence.t -> ('a -> 'b) -> 'b Base__Sequence.t
end
val bind : 'a sequence -> f:('a -> 'b sequence) -> 'b sequence
val return : 'a -> 'a sequence
val map : 'a sequence -> f:('a -> 'b) -> 'b sequence
val join : 'a sequence sequence -> 'a sequence
val ignore_m : 'a sequence -> unit sequence
val all : 'a sequence list -> 'a list sequence
val all_ignore : unit sequence list -> unit sequence
module Let_syntax :
sig
val return : 'a -> 'a Base__Sequence.t
val ( >>= ) :
'a Base__Sequence.t ->
('a -> 'b Base__Sequence.t) -> 'b Base__Sequence.t
val ( >>| ) :
'a Base__Sequence.t -> ('a -> 'b) -> 'b Base__Sequence.t
module Let_syntax :
sig
val return : 'a -> 'a Base__Sequence.t
val bind :
'a Base__Sequence.t ->
f:('a -> 'b Base__Sequence.t) -> 'b Base__Sequence.t
val map :
'a Base__Sequence.t ->
f:('a -> 'b) -> 'b Base__Sequence.t
val both :
'a Base__Sequence.t ->
'b Base__Sequence.t -> ('a * 'b) Base__Sequence.t
module Open_on_rhs : sig end
end
end
val empty : 'a sequence
val next : 'a sequence -> ('a * 'a sequence) option
module Step :
sig
type ('a, 's) t =
('a, 's) Base__Sequence.Step.t =
Done
| Skip of 's
| Yield of 'a * 's
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
('s -> Base__.Sexplib.Sexp.t) ->
('a, 's) t -> Base__.Sexplib.Sexp.t
end
val unfold_step :
init:'s -> f:('s -> ('a, 's) Step.t) -> 'a sequence
val unfold : init:'s -> f:('s -> ('a * 's) option) -> 'a sequence
val unfold_with :
'a sequence ->
init:'s -> f:('s -> 'a -> ('b, 's) Step.t) -> 'b sequence
val unfold_with_and_finish :
'a sequence ->
init:'s_a ->
running_step:('s_a -> 'a -> ('b, 's_a) Step.t) ->
inner_finished:('s_a -> 's_b) ->
finishing_step:('s_b -> ('b, 's_b) Step.t) -> 'b sequence
val nth : 'a sequence -> int -> 'a option
val nth_exn : 'a sequence -> int -> 'a
val mapi : 'a sequence -> f:(int -> 'a -> 'b) -> 'b sequence
val filteri : 'a sequence -> f:(int -> 'a -> bool) -> 'a sequence
val merge :
'a sequence ->
'a sequence -> cmp:('a -> 'a -> int) -> 'a sequence
val merge_with_duplicates :
'a sequence ->
'b sequence ->
cmp:('a -> 'b -> int) ->
('a, 'b) Merge_with_duplicates_element.t sequence
val hd : 'a sequence -> 'a option
val hd_exn : 'a sequence -> 'a
val tl : 'a sequence -> 'a sequence option
val tl_eagerly_exn : 'a sequence -> 'a sequence
val find_mapi :
'a sequence -> f:(int -> 'a -> 'b option) -> 'b option
val findi :
'a sequence -> f:(int -> 'a -> bool) -> (int * 'a) option
val find_exn : 'a sequence -> f:('a -> bool) -> 'a
val for_alli : 'a sequence -> f:(int -> 'a -> bool) -> bool
val existsi : 'a sequence -> f:(int -> 'a -> bool) -> bool
val append : 'a sequence -> 'a sequence -> 'a sequence
val concat : 'a sequence sequence -> 'a sequence
val concat_map :
'a sequence -> f:('a -> 'b sequence) -> 'b sequence
val concat_mapi :
'a sequence -> f:(int -> 'a -> 'b sequence) -> 'b sequence
val interleave : 'a sequence sequence -> 'a sequence
val zip : 'a sequence -> 'b sequence -> ('a * 'b) sequence
val zip_full :
'a sequence ->
'b sequence ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] sequence
val iteri : 'a sequence -> f:(int -> 'a -> unit) -> unit
val foldi :
'a sequence -> f:(int -> 'b -> 'a -> 'b) -> init:'b -> 'b
val reduce_exn : 'a sequence -> f:('a -> 'a -> 'a) -> 'a
val reduce : 'a sequence -> f:('a -> 'a -> 'a) -> 'a option
val find_consecutive_duplicate :
'a sequence -> equal:('a -> 'a -> bool) -> ('a * 'a) option
val remove_consecutive_duplicates :
'a sequence -> equal:('a -> 'a -> bool) -> 'a sequence
val range :
?stride:int ->
?start:[ `exclusive | `inclusive ] ->
?stop:[ `exclusive | `inclusive ] -> int -> int -> int sequence
val init : int -> f:(int -> 'a) -> 'a sequence
val filter_map : 'a sequence -> f:('a -> 'b option) -> 'b sequence
val filter_mapi :
'a sequence -> f:(int -> 'a -> 'b option) -> 'b sequence
val filter_opt : 'a option sequence -> 'a sequence
val sub : 'a sequence -> pos:int -> len:int -> 'a sequence
val take : 'a sequence -> int -> 'a sequence
val drop : 'a sequence -> int -> 'a sequence
val drop_eagerly : 'a sequence -> int -> 'a sequence
val take_while : 'a sequence -> f:('a -> bool) -> 'a sequence
val drop_while : 'a sequence -> f:('a -> bool) -> 'a sequence
val drop_while_option :
'a sequence -> f:('a -> bool) -> ('a * 'a sequence) option
val split_n : 'a sequence -> int -> 'a list * 'a sequence
val split_n_eagerly :
'a sequence -> int -> 'a sequence * 'a sequence
val chunks_exn : 'a sequence -> int -> 'a list sequence
val shift_right : 'a sequence -> 'a -> 'a sequence
val shift_right_with_list : 'a sequence -> 'a list -> 'a sequence
val shift_left : 'a sequence -> int -> 'a sequence
module Infix :
sig
val ( @ ) :
'a Base__Sequence.t ->
'a Base__Sequence.t -> 'a Base__Sequence.t
end
val cartesian_product :
'a sequence -> 'b sequence -> ('a * 'b) sequence
val interleaved_cartesian_product :
'a sequence -> 'b sequence -> ('a * 'b) sequence
val intersperse : 'a sequence -> sep:'a -> 'a sequence
val cycle_list_exn : 'a list -> 'a sequence
val repeat : 'a -> 'a sequence
val singleton : 'a -> 'a sequence
val delayed_fold :
'a sequence ->
init:'s ->
f:('s -> 'a -> k:('s -> 'r) -> 'r) -> finish:('s -> 'r) -> 'r
val to_list : 'a sequence -> 'a list
val to_list_rev : 'a sequence -> 'a list
val of_list : 'a list -> 'a sequence
val of_lazy : 'a sequence Base__.Lazy.t -> 'a sequence
val memoize : 'a sequence -> 'a sequence
val force_eagerly : 'a sequence -> 'a sequence
val bounded_length :
'a sequence -> at_most:int -> [ `Greater | `Is of int ]
val length_is_bounded_by :
?min:int -> ?max:int -> 'a sequence -> bool
module Generator :
sig
type ('a, 'e) t = ('a, 'e) Base__Sequence.Generator.t
val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
val yield : 'elt -> (unit, 'elt) t
val of_sequence :
'elt Base__Sequence.sequence -> (unit, 'elt) t
val run : (unit, 'elt) t -> 'elt Base__Sequence.sequence
end
val filter : 'a sequence -> f:('a -> bool) -> 'a sequence
val compare :
('a -> 'b -> int) -> 'a sequence -> 'b sequence -> int
val of_array : 'a array -> 'a sequence
val cons : 'a -> 'a sequence -> 'a sequence
val is_empty : 'a sequence -> bool
val pp : 'a Regular.Std.printer -> 'a sequence Regular.Std.printer
end
type 'a seq = 'a Bap.Std.Seq.t
val bin_seq :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a seq Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_seq :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a seq Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_seq__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a seq) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_seq :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a seq Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_seq :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a seq Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_seq :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a seq Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_seq :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a seq Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_seq :
Core_kernel.Std.Bin_prot.Shape.t -> Core_kernel.Std.Bin_prot.Shape.t
val compare_seq : ('a -> 'a -> int) -> 'a seq -> 'a seq -> int
val seq_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a seq
val sexp_of_seq : ('a -> Sexplib.Sexp.t) -> 'a seq -> Sexplib.Sexp.t
module Trie :
sig
module type Key =
sig
type t
type token
val bin_token : token Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_token : token Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_token__ :
(int -> token) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_token :
token Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_token : token Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_token :
token Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_token :
token Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_token : Core_kernel.Std.Bin_prot.Shape.t
val compare_token : token -> token -> int
val token_of_sexp : Sexplib.Sexp.t -> token
val sexp_of_token : token -> Sexplib.Sexp.t
val length : Bap.Std.Trie.Key.t -> int
val nth_token :
Bap.Std.Trie.Key.t -> int -> Bap.Std.Trie.Key.token
val token_hash : Bap.Std.Trie.Key.token -> int
end
module type S =
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key
val create : unit -> 'a Bap.Std.Trie.S.t
val add :
'a Bap.Std.Trie.S.t ->
key:Bap.Std.Trie.S.key -> data:'a -> unit
val change :
'a Bap.Std.Trie.S.t ->
Bap.Std.Trie.S.key -> ('a option -> 'a option) -> unit
val find :
'a Bap.Std.Trie.S.t -> Bap.Std.Trie.S.key -> 'a option
val walk :
'a Bap.Std.Trie.S.t ->
Bap.Std.Trie.S.key ->
init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a Bap.Std.Trie.S.t -> Bap.Std.Trie.S.key -> unit
val longest_match :
'a Bap.Std.Trie.S.t ->
Bap.Std.Trie.S.key -> (int * 'a) option
val length : 'a Bap.Std.Trie.S.t -> int
val pp :
'a Regular.Std.printer ->
'a Bap.Std.Trie.S.t Regular.Std.printer
end
module Make :
functor (Key : Key) ->
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Key.t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change : 'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module type Token =
sig
type t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val hash : Bap.Std.Trie.Token.t -> int
end
module Array :
sig
module Prefix :
functor (Tok : Token) ->
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Tok.t array
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module Suffix :
functor (Tok : Token) ->
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Tok.t array
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
end
module String :
sig
module Prefix :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = string
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module Suffix :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Prefix.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
end
end
module Interval_tree :
sig
module type Interval =
sig
type t
val compare : t -> t -> int
val sexp_of_t : t -> Sexplib.Sexp.t
type point
val compare_point : point -> point -> int
val sexp_of_point : point -> Sexplib.Sexp.t
val lower :
Bap.Std.Interval_tree.Interval.t ->
Bap.Std.Interval_tree.Interval.point
val upper :
Bap.Std.Interval_tree.Interval.t ->
Bap.Std.Interval_tree.Interval.point
end
module type S =
sig
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key
type point
val empty : 'a Bap.Std.Interval_tree.S.t
val singleton :
Bap.Std.Interval_tree.S.key ->
'a -> 'a Bap.Std.Interval_tree.S.t
val least :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.point option
val greatest :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.point option
val min_binding :
'a Bap.Std.Interval_tree.S.t ->
(Bap.Std.Interval_tree.S.key * 'a) option
val max_binding :
'a Bap.Std.Interval_tree.S.t ->
(Bap.Std.Interval_tree.S.key * 'a) option
val add :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.key ->
'a -> 'a Bap.Std.Interval_tree.S.t
val dominators :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.key ->
(Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Std.Sequence.t
val intersections :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.key ->
(Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Std.Sequence.t
val intersects :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.key -> bool
val dominates :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.key -> bool
val contains :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.point -> bool
val lookup :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.point ->
(Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Std.Sequence.t
val map :
'a Bap.Std.Interval_tree.S.t ->
f:('a -> 'b) -> 'b Bap.Std.Interval_tree.S.t
val mapi :
'a Bap.Std.Interval_tree.S.t ->
f:(Bap.Std.Interval_tree.S.key -> 'a -> 'b) ->
'b Bap.Std.Interval_tree.S.t
val filter :
'a Bap.Std.Interval_tree.S.t ->
f:('a -> bool) -> 'a Bap.Std.Interval_tree.S.t
val filter_map :
'a Bap.Std.Interval_tree.S.t ->
f:('a -> 'b option) -> 'b Bap.Std.Interval_tree.S.t
val filter_mapi :
'a Bap.Std.Interval_tree.S.t ->
f:(Bap.Std.Interval_tree.S.key -> 'a -> 'b option) ->
'b Bap.Std.Interval_tree.S.t
val remove :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.key -> 'a Bap.Std.Interval_tree.S.t
val remove_intersections :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.key -> 'a Bap.Std.Interval_tree.S.t
val remove_dominators :
'a Bap.Std.Interval_tree.S.t ->
Bap.Std.Interval_tree.S.key -> 'a Bap.Std.Interval_tree.S.t
val to_sequence :
'a Bap.Std.Interval_tree.S.t ->
(Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Std.Sequence.t
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
end
module Make :
functor (Interval : Interval) ->
sig
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val empty : 'a t
val singleton : Interval.t -> 'a -> 'a t
val least : 'a t -> Interval.point option
val greatest : 'a t -> Interval.point option
val min_binding : 'a t -> (Interval.t * 'a) option
val max_binding : 'a t -> (Interval.t * 'a) option
val add : 'a t -> Interval.t -> 'a -> 'a t
val dominators :
'a t -> Interval.t -> (Interval.t * 'a) Seq.t
val intersections :
'a t -> Interval.t -> (Interval.t * 'a) Seq.t
val intersects : 'a t -> Interval.t -> bool
val dominates : 'a t -> Interval.t -> bool
val contains : 'a t -> Interval.point -> bool
val lookup :
'a t -> Interval.point -> (Interval.t * 'a) Seq.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(Interval.t -> 'a -> 'b) -> 'b t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(Interval.t -> 'a -> 'b option) -> 'b t
val remove : 'a t -> Interval.t -> 'a t
val remove_intersections : 'a t -> Interval.t -> 'a t
val remove_dominators : 'a t -> Interval.t -> 'a t
val to_sequence : 'a t -> (Interval.t * 'a) Seq.t
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
end
module type Interval_binable =
sig
type t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
type point
val bin_point : point Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_point : point Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_point__ :
(int -> point) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_point :
point Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_point : point Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_point :
point Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_point :
point Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_point : Core_kernel.Std.Bin_prot.Shape.t
val point_of_sexp : Sexplib.Sexp.t -> point
val compare : t -> t -> int
val sexp_of_t : t -> Sexplib.Sexp.t
val compare_point : point -> point -> int
val sexp_of_point : point -> Sexplib.Sexp.t
val lower : t -> point
val upper : t -> point
end
module type S_binable =
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key
type point
val empty : 'a t
val singleton : key -> 'a -> 'a t
val least : 'a t -> point option
val greatest : 'a t -> point option
val min_binding : 'a t -> (key * 'a) option
val max_binding : 'a t -> (key * 'a) option
val add : 'a t -> key -> 'a -> 'a t
val dominators : 'a t -> key -> (key * 'a) Seq.t
val intersections : 'a t -> key -> (key * 'a) Seq.t
val intersects : 'a t -> key -> bool
val dominates : 'a t -> key -> bool
val contains : 'a t -> point -> bool
val lookup : 'a t -> point -> (key * 'a) Seq.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key -> 'a -> 'b) -> 'b t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi : 'a t -> f:(key -> 'a -> 'b option) -> 'b t
val remove : 'a t -> key -> 'a t
val remove_intersections : 'a t -> key -> 'a t
val remove_dominators : 'a t -> key -> 'a t
val to_sequence : 'a t -> (key * 'a) Seq.t
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
end
module Make_binable :
functor (Interval : Interval_binable) ->
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val empty : 'a t
val singleton : Interval.t -> 'a -> 'a t
val least : 'a t -> Interval.point option
val greatest : 'a t -> Interval.point option
val min_binding : 'a t -> (Interval.t * 'a) option
val max_binding : 'a t -> (Interval.t * 'a) option
val add : 'a t -> Interval.t -> 'a -> 'a t
val dominators :
'a t -> Interval.t -> (Interval.t * 'a) Seq.t
val intersections :
'a t -> Interval.t -> (Interval.t * 'a) Seq.t
val intersects : 'a t -> Interval.t -> bool
val dominates : 'a t -> Interval.t -> bool
val contains : 'a t -> Interval.point -> bool
val lookup :
'a t -> Interval.point -> (Interval.t * 'a) Seq.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(Interval.t -> 'a -> 'b) -> 'b t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(Interval.t -> 'a -> 'b option) -> 'b t
val remove : 'a t -> Interval.t -> 'a t
val remove_intersections : 'a t -> Interval.t -> 'a t
val remove_dominators : 'a t -> Interval.t -> 'a t
val to_sequence : 'a t -> (Interval.t * 'a) Seq.t
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
end
end
type value
val bin_value : value Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_value : value Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_value__ :
(int -> value) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_value : value Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_value : value Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_value : value Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_value : value Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_value : Core_kernel.Std.Bin_prot.Shape.t
val compare_value : value -> value -> int
val value_of_sexp : Sexplib.Sexp.t -> value
val sexp_of_value : value -> Sexplib.Sexp.t
type dict
val bin_dict : dict Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_dict : dict Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_dict__ :
(int -> dict) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_dict : dict Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_dict : dict Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_dict : dict Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_dict : dict Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_dict : Core_kernel.Std.Bin_prot.Shape.t
val compare_dict : dict -> dict -> int
val dict_of_sexp : Sexplib.Sexp.t -> dict
val sexp_of_dict : dict -> Sexplib.Sexp.t
type word
val bin_word : word Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_word : word Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_word__ :
(int -> word) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_word : word Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_word : word Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_word : word Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_word : word Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_word : Core_kernel.Std.Bin_prot.Shape.t
val compare_word : word -> word -> int
val word_of_sexp : Sexplib.Sexp.t -> word
val sexp_of_word : word -> Sexplib.Sexp.t
type addr = Bap.Std.word
val bin_addr : addr Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_addr : addr Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_addr__ :
(int -> addr) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_addr : addr Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_addr : addr Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_addr : addr Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_addr : addr Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_addr : Core_kernel.Std.Bin_prot.Shape.t
val compare_addr : addr -> addr -> int
val addr_of_sexp : Sexplib.Sexp.t -> addr
val sexp_of_addr : addr -> Sexplib.Sexp.t
module Size :
sig
type all = [ `r128 | `r16 | `r256 | `r32 | `r64 | `r8 ]
val r8 : all
val r16 : all
val r32 : all
val r64 : all
val r128 : all
val r256 : all
module Variants_of_all :
sig
val r8 : all Variantslib.Variant.t
val r16 : all Variantslib.Variant.t
val r32 : all Variantslib.Variant.t
val r64 : all Variantslib.Variant.t
val r128 : all Variantslib.Variant.t
val r256 : all Variantslib.Variant.t
val fold :
init:'acc__ ->
r8:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
r16:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
r32:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
r64:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
r128:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
r256:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
'acc__
val iter :
r8:(all Variantslib.Variant.t -> unit) ->
r16:(all Variantslib.Variant.t -> unit) ->
r32:(all Variantslib.Variant.t -> unit) ->
r64:(all Variantslib.Variant.t -> unit) ->
r128:(all Variantslib.Variant.t -> unit) ->
r256:(all Variantslib.Variant.t -> unit) -> unit
val map :
all ->
r8:(all Variantslib.Variant.t -> 'result__) ->
r16:(all Variantslib.Variant.t -> 'result__) ->
r32:(all Variantslib.Variant.t -> 'result__) ->
r64:(all Variantslib.Variant.t -> 'result__) ->
r128:(all Variantslib.Variant.t -> 'result__) ->
r256:(all Variantslib.Variant.t -> 'result__) -> 'result__
val to_rank : all -> int
val to_name : all -> Trie.String.Suffix.key
val descriptions : (Trie.String.Suffix.key * int) list
end
type 'a p = 'a constraint 'a = [< Bap.Std.Size.all ]
val bin_p :
([< all ] as 'a) Core_kernel.Std.Bin_prot.Type_class.t ->
'a Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_p :
([< all ] as 'a) Core_kernel.Std.Bin_prot.Read.reader ->
'a Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_p__ :
([< all ] as 'a) Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_p :
([< all ] as 'a) Core_kernel.Std.Bin_prot.Type_class.reader ->
'a Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_p :
([< all ] as 'a) Core_kernel.Std.Bin_prot.Size.sizer ->
'a Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_p :
([< all ] as 'a) Core_kernel.Std.Bin_prot.Write.writer ->
'a Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_p :
([< all ] as 'a) Core_kernel.Std.Bin_prot.Type_class.writer ->
'a Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_p :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val compare_p : (([< all ] as 'a) -> 'a -> int) -> 'a -> 'a -> int
val p_of_sexp :
(Sexplib.Sexp.t -> ([< all ] as 'a)) -> Sexplib.Sexp.t -> 'a
val sexp_of_p :
(([< all ] as 'a) -> Sexplib.Sexp.t) -> 'a -> Sexplib.Sexp.t
type t = Bap.Std.Size.all Bap.Std.Size.p
val of_int : int -> Bap.Std.Size.t Core_kernel.Std.Or_error.t
val of_int_exn : int -> Bap.Std.Size.t
val of_int_opt : int -> Bap.Std.Size.t option
val addr_of_int : int -> [ `r32 | `r64 ] Core_kernel.Std.Or_error.t
val addr_of_int_exn : int -> [ `r32 | `r64 ]
val addr_of_int_opt : int -> [ `r32 | `r64 ] option
val addr_of_word_size :
Core_kernel.Std.Word_size.t -> [ `r32 | `r64 ]
val word_of_addr_size :
[ `r32 | `r64 ] -> Core_kernel.Std.Word_size.t
val to_addr_size :
Bap.Std.Size.t -> [ `r32 | `r64 ] Core_kernel.Std.Or_error.t
val in_bits : [< Bap.Std.Size.all ] Bap.Std.Size.p -> int
val in_bytes : [< Bap.Std.Size.all ] Bap.Std.Size.p -> int
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
type size = Bap.Std.Size.t
val bin_size : size Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_size : size Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_size__ :
(int -> size) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_size : size Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_size : size Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_size : size Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_size : size Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_size : Core_kernel.Std.Bin_prot.Shape.t
val compare_size : size -> size -> int
val size_of_sexp : Sexplib.Sexp.t -> size
val sexp_of_size : size -> Sexplib.Sexp.t
type addr_size = [ `r32 | `r64 ] Bap.Std.Size.p
val bin_addr_size : addr_size Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_addr_size : addr_size Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_addr_size__ :
(int -> addr_size) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_addr_size :
addr_size Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_addr_size : addr_size Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_addr_size :
addr_size Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_addr_size :
addr_size Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_addr_size : Core_kernel.Std.Bin_prot.Shape.t
val compare_addr_size : addr_size -> addr_size -> int
val addr_size_of_sexp : Sexplib.Sexp.t -> addr_size
val sexp_of_addr_size : addr_size -> Sexplib.Sexp.t
module Bitvector :
sig
type t = Bap.Std.word
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.word
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Size.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
module Mono :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Hash_set.elt
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Hash_set.elt
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
end
type endian = LittleEndian | BigEndian
val bin_endian : endian Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_endian : endian Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_endian__ :
(int -> endian) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_endian :
endian Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_endian : endian Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_endian : endian Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_endian :
endian Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_endian : Core_kernel.Std.Bin_prot.Shape.t
val compare_endian : endian -> endian -> int
val endian_of_sexp : Sexplib.Sexp.t -> endian
val sexp_of_endian : endian -> Sexplib.Sexp.t
val of_string : string -> Bap.Std.Bitvector.t
val of_bool : bool -> Bap.Std.Bitvector.t
val of_int : width:int -> int -> Bap.Std.Bitvector.t
val of_int32 : ?width:int -> int32 -> Bap.Std.Bitvector.t
val of_int64 : ?width:int -> int64 -> Bap.Std.Bitvector.t
val b0 : Bap.Std.Bitvector.t
val b1 : Bap.Std.Bitvector.t
val one : int -> Bap.Std.Bitvector.t
val zero : int -> Bap.Std.Bitvector.t
val ones : int -> Bap.Std.Bitvector.t
val of_binary :
?width:int ->
Bap.Std.Bitvector.endian -> string -> Bap.Std.Bitvector.t
val to_int : Bap.Std.Bitvector.t -> int Core_kernel.Std.Or_error.t
val to_int32 :
Bap.Std.Bitvector.t -> int32 Core_kernel.Std.Or_error.t
val to_int64 :
Bap.Std.Bitvector.t -> int64 Core_kernel.Std.Or_error.t
val to_int_exn : Bap.Std.Bitvector.t -> int
val to_int32_exn : Bap.Std.Bitvector.t -> int32
val to_int64_exn : Bap.Std.Bitvector.t -> int64
val pp : Bap.Std.Bitvector.t Regular.Std.printer
val pp_hex : Bap.Std.Bitvector.t Regular.Std.printer
val pp_dec : Bap.Std.Bitvector.t Regular.Std.printer
val pp_oct : Bap.Std.Bitvector.t Regular.Std.printer
val pp_bin : Bap.Std.Bitvector.t Regular.Std.printer
val pp_hex_full : Bap.Std.Bitvector.t Regular.Std.printer
val pp_dec_full : Bap.Std.Bitvector.t Regular.Std.printer
val pp_oct_full : Bap.Std.Bitvector.t Regular.Std.printer
val pp_bin_full : Bap.Std.Bitvector.t Regular.Std.printer
val pp_generic :
?case:[ `lower | `upper ] ->
?prefix:[ `auto | `base | `none | `this of string ] ->
?suffix:[ `full | `none | `size ] ->
?format:[ `bin | `dec | `hex | `oct ] ->
Bap.Std.Bitvector.t Regular.Std.printer
val string_of_value : ?hex:bool -> Bap.Std.Bitvector.t -> string
val signed : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val unsigned : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val is_zero : Bap.Std.Bitvector.t -> bool
val is_one : Bap.Std.Bitvector.t -> bool
val bitwidth : Bap.Std.Bitvector.t -> int
val extract :
?hi:int ->
?lo:int ->
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val extract_exn :
?hi:int -> ?lo:int -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val concat :
Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val ( @. ) :
Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val succ : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val pred : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val nsucc : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
val npred : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
val ( ++ ) : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
val ( -- ) : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
val gcd :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val lcm :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val gcdext :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t ->
(Bap.Std.Bitvector.t * Bap.Std.Bitvector.t * Bap.Std.Bitvector.t)
Core_kernel.Std.Or_error.t
val gcd_exn :
Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val lcm_exn :
Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val gcdext_exn :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t * Bap.Std.Bitvector.t * Bap.Std.Bitvector.t
val enum_bytes :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.endian -> Bap.Std.Bitvector.t Bap.Std.seq
val enum_chars :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.endian -> char Bap.Std.seq
val enum_bits :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.endian -> bool Bap.Std.seq
val validate_positive :
Bap.Std.Bitvector.t Core_kernel.Std.Validate.check
val validate_non_negative :
Bap.Std.Bitvector.t Core_kernel.Std.Validate.check
val validate_negative :
Bap.Std.Bitvector.t Core_kernel.Std.Validate.check
val validate_non_positive :
Bap.Std.Bitvector.t Core_kernel.Std.Validate.check
val is_positive : Bap.Std.Bitvector.t -> bool
val is_non_negative : Bap.Std.Bitvector.t -> bool
val is_negative : Bap.Std.Bitvector.t -> bool
val is_non_positive : Bap.Std.Bitvector.t -> bool
module Int_err :
sig
val ( !$ ) :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i1 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i4 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i8 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i16 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i32 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i64 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val int :
int ->
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val of_word_size :
Core_kernel.Std.Word_size.t ->
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
type t = Hash_set.elt Core_kernel.Std.Or_error.t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
val ( >>= ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b Core_kernel.Std.Or_error.t) ->
'b Core_kernel.Std.Or_error.t
val ( >>| ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b) -> 'b Core_kernel.Std.Or_error.t
end
module Int_exn :
sig
type t = Hash_set.elt
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
module Unsafe :
sig
type t = Int_exn.t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
module Stable :
sig
module V1 :
sig
type nonrec t = Bap.Std.Bitvector.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module V2 :
sig
type nonrec t = Bap.Std.Bitvector.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
end
module Trie :
sig
module Big :
sig
module Bits :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Unsafe.t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module Bytes :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Bits.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
end
module Little :
sig
module Bits :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Unsafe.t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module Bytes :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Bits.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
end
end
end
type endian = Bap.Std.Bitvector.endian = LittleEndian | BigEndian
val endian_of_sexp : Sexplib.Sexp.t -> endian
val sexp_of_endian : endian -> Sexplib.Sexp.t
val bin_endian : endian Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_endian : endian Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_endian__ :
(int -> endian) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_endian :
endian Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_endian : endian Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_endian : endian Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_endian :
endian Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_endian : Core_kernel.Std.Bin_prot.Shape.t
val compare_endian : endian -> endian -> int
module Word :
sig
type t = word
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness = Bitvector.comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = word
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Bitvector.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(word, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : word -> 'a -> 'a t
val of_alist :
(word * 'a) list ->
[ `Duplicate_key of word | `Ok of 'a t ]
val of_alist_or_error :
(word * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (word * 'a) list -> 'a t
val of_alist_multi : (word * 'a) list -> 'a list t
val of_alist_fold :
(word * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(word * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(word * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (word * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> word * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:word -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of word | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(word, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
word Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:word -> data:'a -> 'a t
val add_multi :
'a list t -> key:word -> data:'a -> 'a list t
val remove_multi : 'a list t -> word -> 'a list t
val change :
'a t -> word -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
val find : 'a t -> word -> 'a option
val find_exn : 'a t -> word -> 'a
val remove : 'a t -> word -> 'a t
val mem : 'a t -> word -> bool
val iter_keys : 'a t -> f:(word -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:word -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:word ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:word -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:word ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(word -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:word -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:word -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:word -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:word -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> word list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (word * 'a) list
val validate :
name:(word -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:word ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(word, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (word * 'a) option
val min_elt_exn : 'a t -> word * 'a
val max_elt : 'a t -> (word * 'a) option
val max_elt_exn : 'a t -> word * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:word -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:word -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:word -> data:'a -> bool) -> int
val split :
'a t -> word -> 'a t * (word * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:word Base__.Maybe_bound.t ->
upper_bound:word Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:word ->
max:word ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:word -> max:word -> (word * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> word -> (word * 'a) option
val nth : 'a t -> int -> (word * 'a) option
val nth_exn : 'a t -> int -> word * 'a
val rank : 'a t -> word -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:word ->
?keys_less_or_equal_to:word ->
'a t -> (word * 'a) Base__.Sequence.t
val obs :
word Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
word Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> word end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(word, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : word -> 'a -> 'a t
val of_alist :
(word * 'a) list -> [ `Duplicate_key of word | `Ok of 'a t ]
val of_alist_or_error :
(word * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (word * 'a) list -> 'a t
val of_alist_multi : (word * 'a) list -> 'a list t
val of_alist_fold :
(word * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(word * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(word * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (word * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> word * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:word -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of word | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(word, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
word Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:word -> data:'a -> 'a t
val add_multi : 'a list t -> key:word -> data:'a -> 'a list t
val remove_multi : 'a list t -> word -> 'a list t
val change : 'a t -> word -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
val find : 'a t -> word -> 'a option
val find_exn : 'a t -> word -> 'a
val remove : 'a t -> word -> 'a t
val mem : 'a t -> word -> bool
val iter_keys : 'a t -> f:(word -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:word -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:word ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:word -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:word ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(word -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:word -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:word -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:word -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:word -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> word list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (word * 'a) list
val validate :
name:(word -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:word ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(word, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (word * 'a) option
val min_elt_exn : 'a t -> word * 'a
val max_elt : 'a t -> (word * 'a) option
val max_elt_exn : 'a t -> word * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:word -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:word -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:word -> data:'a -> bool) -> int
val split : 'a t -> word -> 'a t * (word * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:word Base__.Maybe_bound.t ->
upper_bound:word Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:word ->
max:word ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:word -> max:word -> (word * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> word -> (word * 'a) option
val nth : 'a t -> int -> (word * 'a) option
val nth_exn : 'a t -> int -> word * 'a
val rank : 'a t -> word -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:word ->
?keys_less_or_equal_to:word ->
'a t -> (word * 'a) Base__.Sequence.t
val obs :
word Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
word Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> word end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : word Bin_prot.Type_class.t
val bin_read_t : word Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> word)
Bin_prot.Read.reader
val bin_reader_t : word Bin_prot.Type_class.reader
val bin_size_t : word Bin_prot.Size.sizer
val bin_write_t : word Bin_prot.Write.writer
val bin_writer_t : word Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> word -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = word
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Bitvector.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(word, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(word -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> word -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(word -> bool) -> bool
val for_all : t -> f:(word -> bool) -> bool
val count : t -> f:(word -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(word -> 'sum) -> 'sum
val find : t -> f:(word -> bool) -> word option
val find_map : t -> f:(word -> 'a option) -> 'a option
val to_list : t -> word list
val to_array : t -> word array
val invariants : t -> bool
val mem : t -> word -> bool
val add : t -> word -> t
val remove : t -> word -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
word ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(word -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of word * word
| `Left of word
| `Right of word ] -> unit) ->
unit
val filter : t -> f:(word -> bool) -> t
val partition_tf : t -> f:(word -> bool) -> t * t
val elements : t -> word list
val min_elt : t -> word option
val min_elt_exn : t -> word
val max_elt : t -> word option
val max_elt_exn : t -> word
val choose : t -> word option
val choose_exn : t -> word
val split : t -> word -> t * word option * t
val group_by : t -> equiv:(word -> word -> bool) -> t list
val find_exn : t -> f:(word -> bool) -> word
val find_index : t -> int -> word option
val nth : t -> int -> word option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:word ->
?less_or_equal_to:word -> t -> word Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:word ->
?less_or_equal_to:word ->
t ->
t ->
(word, word)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(word -> 'data) ->
(word, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
word Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
word Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : word -> t
val union_list : t list -> t
val of_list : word list -> t
val of_array : word array -> t
val of_sorted_array : word array -> t Base__.Or_error.t
val of_sorted_array_unchecked : word array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> word) -> t
val stable_dedup_list : word list -> word list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> word) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> word option) -> t
val of_tree : t -> t
val of_hash_set : word Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(word, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(word, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
word Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> word end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (word, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(word -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> word -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(word -> bool) -> bool
val for_all : t -> f:(word -> bool) -> bool
val count : t -> f:(word -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(word -> 'sum) -> 'sum
val find : t -> f:(word -> bool) -> word option
val find_map : t -> f:(word -> 'a option) -> 'a option
val to_list : t -> word list
val to_array : t -> word array
val invariants : t -> bool
val mem : t -> word -> bool
val add : t -> word -> t
val remove : t -> word -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
word ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(word -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of word * word | `Left of word | `Right of word ] ->
unit) ->
unit
val filter : t -> f:(word -> bool) -> t
val partition_tf : t -> f:(word -> bool) -> t * t
val elements : t -> word list
val min_elt : t -> word option
val min_elt_exn : t -> word
val max_elt : t -> word option
val max_elt_exn : t -> word
val choose : t -> word option
val choose_exn : t -> word
val split : t -> word -> t * word option * t
val group_by : t -> equiv:(word -> word -> bool) -> t list
val find_exn : t -> f:(word -> bool) -> word
val find_index : t -> int -> word option
val nth : t -> int -> word option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:word ->
?less_or_equal_to:word -> t -> word Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:word ->
?less_or_equal_to:word ->
t ->
t ->
(word, word)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(word -> 'data) ->
(word, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
word Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
word Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : word -> t
val union_list : t list -> t
val of_list : word list -> t
val of_array : word array -> t
val of_sorted_array : word array -> t Base__.Or_error.t
val of_sorted_array_unchecked : word array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> word) -> t
val stable_dedup_list : word list -> word list
val map : ('a, 'b) Base.Set.t -> f:('a -> word) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> word option) -> t
val of_tree : Tree.t -> t
val of_hash_set : word Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(word, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(word, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
word Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> word end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : word Bin_prot.Type_class.t
val bin_read_t : word Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> word)
Bin_prot.Read.reader
val bin_reader_t : word Bin_prot.Type_class.reader
val bin_size_t : word Bin_prot.Size.sizer
val bin_write_t : word Bin_prot.Write.writer
val bin_writer_t : word Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> word -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Bitvector.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = word
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> word -> Core_kernel__.Import.bool
val lookup : 'a t -> word -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> word -> 'a
val enqueue :
'a t -> word -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> word -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> word -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> word -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (word * 'a) Core_kernel__.Import.option
val keys : 'a t -> word Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (word * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> word * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> word -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> word -> Core_kernel__.Import.unit
val replace : 'a t -> word -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> word -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:word -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:word -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
module Mono :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = word
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(word, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : word -> 'a -> 'a t
val of_alist :
(word * 'a) list ->
[ `Duplicate_key of word | `Ok of 'a t ]
val of_alist_or_error :
(word * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (word * 'a) list -> 'a t
val of_alist_multi : (word * 'a) list -> 'a list t
val of_alist_fold :
(word * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(word * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(word * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(word * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> word * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:word -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of word | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(word, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
word Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:word -> data:'a -> 'a t
val add_multi :
'a list t -> key:word -> data:'a -> 'a list t
val remove_multi : 'a list t -> word -> 'a list t
val change :
'a t -> word -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> word -> f:('a option -> 'a) -> 'a t
val find : 'a t -> word -> 'a option
val find_exn : 'a t -> word -> 'a
val remove : 'a t -> word -> 'a t
val mem : 'a t -> word -> bool
val iter_keys : 'a t -> f:(word -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:word -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:word ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:word -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:word ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(word -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:word -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:word -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:word -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:word -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> word list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (word * 'a) list
val validate :
name:(word -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:word ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(word, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (word * 'a) option
val min_elt_exn : 'a t -> word * 'a
val max_elt : 'a t -> (word * 'a) option
val max_elt_exn : 'a t -> word * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:word -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:word -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:word -> data:'a -> bool) -> int
val split :
'a t -> word -> 'a t * (word * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:word Base__.Maybe_bound.t ->
upper_bound:word Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:word ->
max:word ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:word -> max:word -> (word * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> word -> (word * 'a) option
val nth : 'a t -> int -> (word * 'a) option
val nth_exn : 'a t -> int -> word * 'a
val rank : 'a t -> word -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:word ->
?keys_less_or_equal_to:word ->
'a t -> (word * 'a) Base__.Sequence.t
val obs :
word Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
word Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> word end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(word, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : word -> 'a -> 'a t
val of_alist :
(word * 'a) list ->
[ `Duplicate_key of word | `Ok of 'a t ]
val of_alist_or_error :
(word * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (word * 'a) list -> 'a t
val of_alist_multi : (word * 'a) list -> 'a list t
val of_alist_fold :
(word * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(word * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(word * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (word * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> word * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:word -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of word | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(word, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
word Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:word -> data:'a -> 'a t
val add_multi :
'a list t -> key:word -> data:'a -> 'a list t
val remove_multi : 'a list t -> word -> 'a list t
val change :
'a t -> word -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
val find : 'a t -> word -> 'a option
val find_exn : 'a t -> word -> 'a
val remove : 'a t -> word -> 'a t
val mem : 'a t -> word -> bool
val iter_keys : 'a t -> f:(word -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:word -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:word ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:word -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:word ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(word -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:word -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:word -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:word -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:word -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> word list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (word * 'a) list
val validate :
name:(word -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:word ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(word, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (word * 'a) option
val min_elt_exn : 'a t -> word * 'a
val max_elt : 'a t -> (word * 'a) option
val max_elt_exn : 'a t -> word * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:word -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:word -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:word -> data:'a -> bool) -> int
val split :
'a t -> word -> 'a t * (word * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:word Base__.Maybe_bound.t ->
upper_bound:word Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:word ->
max:word ->
init:'b -> f:(key:word -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:word -> max:word -> (word * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> word -> (word * 'a) option
val nth : 'a t -> int -> (word * 'a) option
val nth_exn : 'a t -> int -> word * 'a
val rank : 'a t -> word -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:word ->
?keys_less_or_equal_to:word ->
'a t -> (word * 'a) Base__.Sequence.t
val obs :
word Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
word Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> word end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : word Bin_prot.Type_class.t
val bin_read_t : word Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> word)
Bin_prot.Read.reader
val bin_reader_t :
word Bin_prot.Type_class.reader
val bin_size_t : word Bin_prot.Size.sizer
val bin_write_t : word Bin_prot.Write.writer
val bin_writer_t :
word Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
word -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = word
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(word, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(word -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> word -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(word -> bool) -> bool
val for_all : t -> f:(word -> bool) -> bool
val count : t -> f:(word -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(word -> 'sum) -> 'sum
val find : t -> f:(word -> bool) -> word option
val find_map : t -> f:(word -> 'a option) -> 'a option
val to_list : t -> word list
val to_array : t -> word array
val invariants : t -> bool
val mem : t -> word -> bool
val add : t -> word -> t
val remove : t -> word -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (word, word) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
word ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(word -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of word * word
| `Left of word
| `Right of word ] -> unit) ->
unit
val filter : t -> f:(word -> bool) -> t
val partition_tf : t -> f:(word -> bool) -> t * t
val elements : t -> word list
val min_elt : t -> word option
val min_elt_exn : t -> word
val max_elt : t -> word option
val max_elt_exn : t -> word
val choose : t -> word option
val choose_exn : t -> word
val split : t -> word -> t * word option * t
val group_by :
t -> equiv:(word -> word -> bool) -> t list
val find_exn : t -> f:(word -> bool) -> word
val find_index : t -> int -> word option
val nth : t -> int -> word option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:word ->
?less_or_equal_to:word -> t -> word Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:word ->
?less_or_equal_to:word ->
t ->
t ->
(word, word)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(word -> 'data) ->
(word, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
word Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
word Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : word -> t
val union_list : t list -> t
val of_list : word list -> t
val of_array : word array -> t
val of_sorted_array : word array -> t Base__.Or_error.t
val of_sorted_array_unchecked : word array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> word) -> t
val stable_dedup_list : word list -> word list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> word) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> word option) -> t
val of_tree : t -> t
val of_hash_set : word Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(word, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(word, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
word Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> word
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (word, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(word -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> word -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(word -> bool) -> bool
val for_all : t -> f:(word -> bool) -> bool
val count : t -> f:(word -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(word -> 'sum) -> 'sum
val find : t -> f:(word -> bool) -> word option
val find_map : t -> f:(word -> 'a option) -> 'a option
val to_list : t -> word list
val to_array : t -> word array
val invariants : t -> bool
val mem : t -> word -> bool
val add : t -> word -> t
val remove : t -> word -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
word ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(word -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of word * word
| `Left of word
| `Right of word ] -> unit) ->
unit
val filter : t -> f:(word -> bool) -> t
val partition_tf : t -> f:(word -> bool) -> t * t
val elements : t -> word list
val min_elt : t -> word option
val min_elt_exn : t -> word
val max_elt : t -> word option
val max_elt_exn : t -> word
val choose : t -> word option
val choose_exn : t -> word
val split : t -> word -> t * word option * t
val group_by : t -> equiv:(word -> word -> bool) -> t list
val find_exn : t -> f:(word -> bool) -> word
val find_index : t -> int -> word option
val nth : t -> int -> word option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:word ->
?less_or_equal_to:word -> t -> word Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:word ->
?less_or_equal_to:word ->
t ->
t ->
(word, word)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(word -> 'data) ->
(word, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
word Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
word Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : word -> t
val union_list : t list -> t
val of_list : word list -> t
val of_array : word array -> t
val of_sorted_array : word array -> t Base__.Or_error.t
val of_sorted_array_unchecked : word array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> word) -> t
val stable_dedup_list : word list -> word list
val map : ('a, 'b) Base.Set.t -> f:('a -> word) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> word option) -> t
val of_tree : Tree.t -> t
val of_hash_set : word Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(word, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(word, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
word Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> word end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : word Bin_prot.Type_class.t
val bin_read_t : word Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> word)
Bin_prot.Read.reader
val bin_reader_t :
word Bin_prot.Type_class.reader
val bin_size_t : word Bin_prot.Size.sizer
val bin_write_t : word Bin_prot.Write.writer
val bin_writer_t :
word Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
word -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
end
type endian = Bap.Std.Bitvector.endian = LittleEndian | BigEndian
val bin_endian : endian Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_endian : endian Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_endian__ :
(int -> endian) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_endian :
endian Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_endian : endian Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_endian : endian Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_endian :
endian Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_endian : Core_kernel.Std.Bin_prot.Shape.t
val compare_endian : endian -> endian -> int
val endian_of_sexp : Sexplib.Sexp.t -> endian
val sexp_of_endian : endian -> Sexplib.Sexp.t
val of_string : Trie.String.Suffix.key -> t
val of_bool : bool -> t
val of_int : width:int -> int -> t
val of_int32 : ?width:int -> int32 -> t
val of_int64 : ?width:int -> int64 -> t
val b0 : t
val b1 : t
val one : int -> t
val zero : int -> t
val ones : int -> t
val of_binary : ?width:int -> endian -> Trie.String.Suffix.key -> t
val to_int : t -> int Core_kernel.Std.Or_error.t
val to_int32 : t -> int32 Core_kernel.Std.Or_error.t
val to_int64 : t -> int64 Core_kernel.Std.Or_error.t
val to_int_exn : t -> int
val to_int32_exn : t -> int32
val to_int64_exn : t -> int64
val pp : t Regular.Std.printer
val pp_hex : t Regular.Std.printer
val pp_dec : t Regular.Std.printer
val pp_oct : t Regular.Std.printer
val pp_bin : t Regular.Std.printer
val pp_hex_full : t Regular.Std.printer
val pp_dec_full : t Regular.Std.printer
val pp_oct_full : t Regular.Std.printer
val pp_bin_full : t Regular.Std.printer
val pp_generic :
?case:[ `lower | `upper ] ->
?prefix:[ `auto | `base | `none | `this of Trie.String.Suffix.key ] ->
?suffix:[ `full | `none | `size ] ->
?format:[ `bin | `dec | `hex | `oct ] -> t Regular.Std.printer
val string_of_value : ?hex:bool -> t -> Trie.String.Suffix.key
val signed : t -> t
val unsigned : t -> t
val is_zero : t -> bool
val is_one : t -> bool
val bitwidth : t -> int
val extract :
?hi:int -> ?lo:int -> t -> t Core_kernel.Std.Or_error.t
val extract_exn : ?hi:int -> ?lo:int -> t -> t
val concat : t -> t -> t
val ( @. ) : t -> t -> t
val succ : t -> t
val pred : t -> t
val nsucc : t -> int -> t
val npred : t -> int -> t
val ( ++ ) : t -> int -> t
val ( -- ) : t -> int -> t
val gcd : t -> t -> t Core_kernel.Std.Or_error.t
val lcm : t -> t -> t Core_kernel.Std.Or_error.t
val gcdext : t -> t -> (t * t * t) Core_kernel.Std.Or_error.t
val gcd_exn : t -> t -> t
val lcm_exn : t -> t -> t
val gcdext_exn : t -> t -> t * t * t
val enum_bytes : t -> endian -> t seq
val enum_chars : t -> endian -> char seq
val enum_bits : t -> endian -> bool seq
val validate_positive : t Core_kernel.Std.Validate.check
val validate_non_negative : t Core_kernel.Std.Validate.check
val validate_negative : t Core_kernel.Std.Validate.check
val validate_non_positive : t Core_kernel.Std.Validate.check
val is_positive : t -> bool
val is_non_negative : t -> bool
val is_negative : t -> bool
val is_non_positive : t -> bool
module Int_err :
sig
val ( !$ ) : t -> t Core_kernel.Std.Or_error.t
val i1 : t -> t Core_kernel.Std.Or_error.t
val i4 : t -> t Core_kernel.Std.Or_error.t
val i8 : t -> t Core_kernel.Std.Or_error.t
val i16 : t -> t Core_kernel.Std.Or_error.t
val i32 : t -> t Core_kernel.Std.Or_error.t
val i64 : t -> t Core_kernel.Std.Or_error.t
val int : int -> t -> t Core_kernel.Std.Or_error.t
val of_word_size :
Core_kernel.Std.Word_size.t ->
t -> t Core_kernel.Std.Or_error.t
type t = word Core_kernel.Std.Or_error.t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
val ( >>= ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b Core_kernel.Std.Or_error.t) ->
'b Core_kernel.Std.Or_error.t
val ( >>| ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b) -> 'b Core_kernel.Std.Or_error.t
end
module Int_exn :
sig
type t = word
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
module Unsafe :
sig
type t = word
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
module Stable :
sig
module V1 :
sig
type nonrec t = t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module V2 :
sig
type nonrec t = t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
end
module Trie :
sig
module Big :
sig
module Bits :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = word
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module Bytes :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = word
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
end
module Little :
sig
module Bits :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = word
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module Bytes :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = word
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
end
end
end
module Addr :
sig
type t = addr
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness = Word.comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = addr
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Word.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(addr, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : addr -> 'a -> 'a t
val of_alist :
(addr * 'a) list ->
[ `Duplicate_key of addr | `Ok of 'a t ]
val of_alist_or_error :
(addr * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (addr * 'a) list -> 'a t
val of_alist_multi : (addr * 'a) list -> 'a list t
val of_alist_fold :
(addr * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(addr * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(addr * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> addr * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:addr -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of addr | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(addr, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
addr Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:addr -> data:'a -> 'a t
val add_multi :
'a list t -> key:addr -> data:'a -> 'a list t
val remove_multi : 'a list t -> addr -> 'a list t
val change :
'a t -> addr -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
val find : 'a t -> addr -> 'a option
val find_exn : 'a t -> addr -> 'a
val remove : 'a t -> addr -> 'a t
val mem : 'a t -> addr -> bool
val iter_keys : 'a t -> f:(addr -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:addr -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:addr ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:addr -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:addr ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:addr -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:addr -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:addr -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:addr -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> addr list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (addr * 'a) list
val validate :
name:(addr -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:addr ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(addr, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (addr * 'a) option
val min_elt_exn : 'a t -> addr * 'a
val max_elt : 'a t -> (addr * 'a) option
val max_elt_exn : 'a t -> addr * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:addr -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:addr -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:addr -> data:'a -> bool) -> int
val split :
'a t -> addr -> 'a t * (addr * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:addr Base__.Maybe_bound.t ->
upper_bound:addr Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:addr ->
max:addr ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:addr -> max:addr -> (addr * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> addr -> (addr * 'a) option
val nth : 'a t -> int -> (addr * 'a) option
val nth_exn : 'a t -> int -> addr * 'a
val rank : 'a t -> addr -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:addr ->
?keys_less_or_equal_to:addr ->
'a t -> (addr * 'a) Base__.Sequence.t
val obs :
addr Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
addr Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> addr end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(addr, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : addr -> 'a -> 'a t
val of_alist :
(addr * 'a) list -> [ `Duplicate_key of addr | `Ok of 'a t ]
val of_alist_or_error :
(addr * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (addr * 'a) list -> 'a t
val of_alist_multi : (addr * 'a) list -> 'a list t
val of_alist_fold :
(addr * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(addr * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(addr * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> addr * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:addr -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of addr | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(addr, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
addr Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:addr -> data:'a -> 'a t
val add_multi : 'a list t -> key:addr -> data:'a -> 'a list t
val remove_multi : 'a list t -> addr -> 'a list t
val change : 'a t -> addr -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
val find : 'a t -> addr -> 'a option
val find_exn : 'a t -> addr -> 'a
val remove : 'a t -> addr -> 'a t
val mem : 'a t -> addr -> bool
val iter_keys : 'a t -> f:(addr -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:addr -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:addr ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:addr -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:addr ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:addr -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:addr -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:addr -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:addr -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> addr list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (addr * 'a) list
val validate :
name:(addr -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:addr ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(addr, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (addr * 'a) option
val min_elt_exn : 'a t -> addr * 'a
val max_elt : 'a t -> (addr * 'a) option
val max_elt_exn : 'a t -> addr * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:addr -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:addr -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:addr -> data:'a -> bool) -> int
val split : 'a t -> addr -> 'a t * (addr * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:addr Base__.Maybe_bound.t ->
upper_bound:addr Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:addr ->
max:addr ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:addr -> max:addr -> (addr * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> addr -> (addr * 'a) option
val nth : 'a t -> int -> (addr * 'a) option
val nth_exn : 'a t -> int -> addr * 'a
val rank : 'a t -> addr -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:addr ->
?keys_less_or_equal_to:addr ->
'a t -> (addr * 'a) Base__.Sequence.t
val obs :
addr Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
addr Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> addr end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : addr Bin_prot.Type_class.t
val bin_read_t : addr Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> addr)
Bin_prot.Read.reader
val bin_reader_t : addr Bin_prot.Type_class.reader
val bin_size_t : addr Bin_prot.Size.sizer
val bin_write_t : addr Bin_prot.Write.writer
val bin_writer_t : addr Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> addr -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = addr
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Word.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(addr, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(addr -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(addr -> bool) -> bool
val for_all : t -> f:(addr -> bool) -> bool
val count : t -> f:(addr -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(addr -> 'sum) -> 'sum
val find : t -> f:(addr -> bool) -> addr option
val find_map : t -> f:(addr -> 'a option) -> 'a option
val to_list : t -> addr list
val to_array : t -> addr array
val invariants : t -> bool
val mem : t -> addr -> bool
val add : t -> addr -> t
val remove : t -> addr -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
addr ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(addr -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of addr * addr
| `Left of addr
| `Right of addr ] -> unit) ->
unit
val filter : t -> f:(addr -> bool) -> t
val partition_tf : t -> f:(addr -> bool) -> t * t
val elements : t -> addr list
val min_elt : t -> addr option
val min_elt_exn : t -> addr
val max_elt : t -> addr option
val max_elt_exn : t -> addr
val choose : t -> addr option
val choose_exn : t -> addr
val split : t -> addr -> t * addr option * t
val group_by : t -> equiv:(addr -> addr -> bool) -> t list
val find_exn : t -> f:(addr -> bool) -> addr
val find_index : t -> int -> addr option
val nth : t -> int -> addr option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:addr ->
?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:addr ->
?less_or_equal_to:addr ->
t ->
t ->
(addr, addr)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(addr -> 'data) ->
(addr, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
addr Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
addr Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : addr -> t
val union_list : t list -> t
val of_list : addr list -> t
val of_array : addr array -> t
val of_sorted_array : addr array -> t Base__.Or_error.t
val of_sorted_array_unchecked : addr array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> addr) -> t
val stable_dedup_list : addr list -> addr list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> addr) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> addr option) -> t
val of_tree : t -> t
val of_hash_set : addr Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(addr, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(addr, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
addr Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> addr end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (addr, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(addr -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(addr -> bool) -> bool
val for_all : t -> f:(addr -> bool) -> bool
val count : t -> f:(addr -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(addr -> 'sum) -> 'sum
val find : t -> f:(addr -> bool) -> addr option
val find_map : t -> f:(addr -> 'a option) -> 'a option
val to_list : t -> addr list
val to_array : t -> addr array
val invariants : t -> bool
val mem : t -> addr -> bool
val add : t -> addr -> t
val remove : t -> addr -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
addr ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(addr -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of addr * addr | `Left of addr | `Right of addr ] ->
unit) ->
unit
val filter : t -> f:(addr -> bool) -> t
val partition_tf : t -> f:(addr -> bool) -> t * t
val elements : t -> addr list
val min_elt : t -> addr option
val min_elt_exn : t -> addr
val max_elt : t -> addr option
val max_elt_exn : t -> addr
val choose : t -> addr option
val choose_exn : t -> addr
val split : t -> addr -> t * addr option * t
val group_by : t -> equiv:(addr -> addr -> bool) -> t list
val find_exn : t -> f:(addr -> bool) -> addr
val find_index : t -> int -> addr option
val nth : t -> int -> addr option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:addr ->
?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:addr ->
?less_or_equal_to:addr ->
t ->
t ->
(addr, addr)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(addr -> 'data) ->
(addr, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
addr Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
addr Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : addr -> t
val union_list : t list -> t
val of_list : addr list -> t
val of_array : addr array -> t
val of_sorted_array : addr array -> t Base__.Or_error.t
val of_sorted_array_unchecked : addr array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> addr) -> t
val stable_dedup_list : addr list -> addr list
val map : ('a, 'b) Base.Set.t -> f:('a -> addr) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> addr option) -> t
val of_tree : Tree.t -> t
val of_hash_set : addr Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(addr, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(addr, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
addr Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> addr end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : addr Bin_prot.Type_class.t
val bin_read_t : addr Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> addr)
Bin_prot.Read.reader
val bin_reader_t : addr Bin_prot.Type_class.reader
val bin_size_t : addr Bin_prot.Size.sizer
val bin_write_t : addr Bin_prot.Write.writer
val bin_writer_t : addr Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> addr -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Word.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = addr
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> addr -> Core_kernel__.Import.bool
val lookup : 'a t -> addr -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> addr -> 'a
val enqueue :
'a t -> addr -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> addr -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> addr -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> addr -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (addr * 'a) Core_kernel__.Import.option
val keys : 'a t -> addr Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (addr * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> addr * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> addr -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> addr -> Core_kernel__.Import.unit
val replace : 'a t -> addr -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> addr -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:addr -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:addr -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
module Mono :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = addr
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(addr, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : addr -> 'a -> 'a t
val of_alist :
(addr * 'a) list ->
[ `Duplicate_key of addr | `Ok of 'a t ]
val of_alist_or_error :
(addr * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (addr * 'a) list -> 'a t
val of_alist_multi : (addr * 'a) list -> 'a list t
val of_alist_fold :
(addr * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(addr * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(addr * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(addr * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> addr * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:addr -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of addr | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(addr, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
addr Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:addr -> data:'a -> 'a t
val add_multi :
'a list t -> key:addr -> data:'a -> 'a list t
val remove_multi : 'a list t -> addr -> 'a list t
val change :
'a t -> addr -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> addr -> f:('a option -> 'a) -> 'a t
val find : 'a t -> addr -> 'a option
val find_exn : 'a t -> addr -> 'a
val remove : 'a t -> addr -> 'a t
val mem : 'a t -> addr -> bool
val iter_keys : 'a t -> f:(addr -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:addr -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:addr ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:addr -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:addr ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:addr -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:addr -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:addr -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:addr -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> addr list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (addr * 'a) list
val validate :
name:(addr -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:addr ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(addr, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (addr * 'a) option
val min_elt_exn : 'a t -> addr * 'a
val max_elt : 'a t -> (addr * 'a) option
val max_elt_exn : 'a t -> addr * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:addr -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:addr -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:addr -> data:'a -> bool) -> int
val split :
'a t -> addr -> 'a t * (addr * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:addr Base__.Maybe_bound.t ->
upper_bound:addr Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:addr ->
max:addr ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:addr -> max:addr -> (addr * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> addr -> (addr * 'a) option
val nth : 'a t -> int -> (addr * 'a) option
val nth_exn : 'a t -> int -> addr * 'a
val rank : 'a t -> addr -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:addr ->
?keys_less_or_equal_to:addr ->
'a t -> (addr * 'a) Base__.Sequence.t
val obs :
addr Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
addr Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> addr end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(addr, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : addr -> 'a -> 'a t
val of_alist :
(addr * 'a) list ->
[ `Duplicate_key of addr | `Ok of 'a t ]
val of_alist_or_error :
(addr * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (addr * 'a) list -> 'a t
val of_alist_multi : (addr * 'a) list -> 'a list t
val of_alist_fold :
(addr * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(addr * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(addr * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> addr * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:addr -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of addr | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(addr, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
addr Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:addr -> data:'a -> 'a t
val add_multi :
'a list t -> key:addr -> data:'a -> 'a list t
val remove_multi : 'a list t -> addr -> 'a list t
val change :
'a t -> addr -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
val find : 'a t -> addr -> 'a option
val find_exn : 'a t -> addr -> 'a
val remove : 'a t -> addr -> 'a t
val mem : 'a t -> addr -> bool
val iter_keys : 'a t -> f:(addr -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:addr -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:addr ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:addr -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:addr ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:addr -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:addr -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:addr -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:addr -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> addr list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (addr * 'a) list
val validate :
name:(addr -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:addr ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(addr, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (addr * 'a) option
val min_elt_exn : 'a t -> addr * 'a
val max_elt : 'a t -> (addr * 'a) option
val max_elt_exn : 'a t -> addr * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:addr -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:addr -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:addr -> data:'a -> bool) -> int
val split :
'a t -> addr -> 'a t * (addr * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:addr Base__.Maybe_bound.t ->
upper_bound:addr Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:addr ->
max:addr ->
init:'b -> f:(key:addr -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:addr -> max:addr -> (addr * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> addr -> (addr * 'a) option
val nth : 'a t -> int -> (addr * 'a) option
val nth_exn : 'a t -> int -> addr * 'a
val rank : 'a t -> addr -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:addr ->
?keys_less_or_equal_to:addr ->
'a t -> (addr * 'a) Base__.Sequence.t
val obs :
addr Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
addr Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> addr end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : addr Bin_prot.Type_class.t
val bin_read_t : addr Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> addr)
Bin_prot.Read.reader
val bin_reader_t :
addr Bin_prot.Type_class.reader
val bin_size_t : addr Bin_prot.Size.sizer
val bin_write_t : addr Bin_prot.Write.writer
val bin_writer_t :
addr Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
addr -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = addr
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(addr, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(addr -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(addr -> bool) -> bool
val for_all : t -> f:(addr -> bool) -> bool
val count : t -> f:(addr -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(addr -> 'sum) -> 'sum
val find : t -> f:(addr -> bool) -> addr option
val find_map : t -> f:(addr -> 'a option) -> 'a option
val to_list : t -> addr list
val to_array : t -> addr array
val invariants : t -> bool
val mem : t -> addr -> bool
val add : t -> addr -> t
val remove : t -> addr -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (addr, addr) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
addr ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(addr -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of addr * addr
| `Left of addr
| `Right of addr ] -> unit) ->
unit
val filter : t -> f:(addr -> bool) -> t
val partition_tf : t -> f:(addr -> bool) -> t * t
val elements : t -> addr list
val min_elt : t -> addr option
val min_elt_exn : t -> addr
val max_elt : t -> addr option
val max_elt_exn : t -> addr
val choose : t -> addr option
val choose_exn : t -> addr
val split : t -> addr -> t * addr option * t
val group_by :
t -> equiv:(addr -> addr -> bool) -> t list
val find_exn : t -> f:(addr -> bool) -> addr
val find_index : t -> int -> addr option
val nth : t -> int -> addr option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:addr ->
?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:addr ->
?less_or_equal_to:addr ->
t ->
t ->
(addr, addr)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(addr -> 'data) ->
(addr, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
addr Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
addr Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : addr -> t
val union_list : t list -> t
val of_list : addr list -> t
val of_array : addr array -> t
val of_sorted_array : addr array -> t Base__.Or_error.t
val of_sorted_array_unchecked : addr array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> addr) -> t
val stable_dedup_list : addr list -> addr list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> addr) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> addr option) -> t
val of_tree : t -> t
val of_hash_set : addr Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(addr, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(addr, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
addr Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> addr
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (addr, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(addr -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(addr -> bool) -> bool
val for_all : t -> f:(addr -> bool) -> bool
val count : t -> f:(addr -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(addr -> 'sum) -> 'sum
val find : t -> f:(addr -> bool) -> addr option
val find_map : t -> f:(addr -> 'a option) -> 'a option
val to_list : t -> addr list
val to_array : t -> addr array
val invariants : t -> bool
val mem : t -> addr -> bool
val add : t -> addr -> t
val remove : t -> addr -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
addr ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(addr -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of addr * addr
| `Left of addr
| `Right of addr ] -> unit) ->
unit
val filter : t -> f:(addr -> bool) -> t
val partition_tf : t -> f:(addr -> bool) -> t * t
val elements : t -> addr list
val min_elt : t -> addr option
val min_elt_exn : t -> addr
val max_elt : t -> addr option
val max_elt_exn : t -> addr
val choose : t -> addr option
val choose_exn : t -> addr
val split : t -> addr -> t * addr option * t
val group_by : t -> equiv:(addr -> addr -> bool) -> t list
val find_exn : t -> f:(addr -> bool) -> addr
val find_index : t -> int -> addr option
val nth : t -> int -> addr option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:addr ->
?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:addr ->
?less_or_equal_to:addr ->
t ->
t ->
(addr, addr)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(addr -> 'data) ->
(addr, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
addr Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
addr Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : addr -> t
val union_list : t list -> t
val of_list : addr list -> t
val of_array : addr array -> t
val of_sorted_array : addr array -> t Base__.Or_error.t
val of_sorted_array_unchecked : addr array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> addr) -> t
val stable_dedup_list : addr list -> addr list
val map : ('a, 'b) Base.Set.t -> f:('a -> addr) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> addr option) -> t
val of_tree : Tree.t -> t
val of_hash_set : addr Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(addr, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(addr, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
addr Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> addr end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : addr Bin_prot.Type_class.t
val bin_read_t : addr Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> addr)
Bin_prot.Read.reader
val bin_reader_t :
addr Bin_prot.Type_class.reader
val bin_size_t : addr Bin_prot.Size.sizer
val bin_write_t : addr Bin_prot.Write.writer
val bin_writer_t :
addr Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
addr -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
end
type endian = Word.endian = LittleEndian | BigEndian
val bin_endian : endian Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_endian : endian Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_endian__ :
(int -> endian) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_endian :
endian Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_endian : endian Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_endian : endian Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_endian :
endian Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_endian : Core_kernel.Std.Bin_prot.Shape.t
val compare_endian : endian -> endian -> int
val endian_of_sexp : Sexplib.Sexp.t -> endian
val sexp_of_endian : endian -> Sexplib.Sexp.t
val of_string : Trie.String.Suffix.key -> t
val of_bool : bool -> t
val of_int : width:int -> int -> t
val of_int32 : ?width:int -> int32 -> t
val of_int64 : ?width:int -> int64 -> t
val b0 : t
val b1 : t
val one : int -> t
val zero : int -> t
val ones : int -> t
val of_binary : ?width:int -> endian -> Trie.String.Suffix.key -> t
val to_int : t -> int Core_kernel.Std.Or_error.t
val to_int32 : t -> int32 Core_kernel.Std.Or_error.t
val to_int64 : t -> int64 Core_kernel.Std.Or_error.t
val to_int_exn : t -> int
val to_int32_exn : t -> int32
val to_int64_exn : t -> int64
val pp : t Regular.Std.printer
val pp_hex : t Regular.Std.printer
val pp_dec : t Regular.Std.printer
val pp_oct : t Regular.Std.printer
val pp_bin : t Regular.Std.printer
val pp_hex_full : t Regular.Std.printer
val pp_dec_full : t Regular.Std.printer
val pp_oct_full : t Regular.Std.printer
val pp_bin_full : t Regular.Std.printer
val pp_generic :
?case:[ `lower | `upper ] ->
?prefix:[ `auto | `base | `none | `this of Trie.String.Suffix.key ] ->
?suffix:[ `full | `none | `size ] ->
?format:[ `bin | `dec | `hex | `oct ] -> t Regular.Std.printer
val string_of_value : ?hex:bool -> t -> Trie.String.Suffix.key
val signed : t -> t
val unsigned : t -> t
val is_zero : t -> bool
val is_one : t -> bool
val bitwidth : t -> int
val extract :
?hi:int -> ?lo:int -> t -> t Core_kernel.Std.Or_error.t
val extract_exn : ?hi:int -> ?lo:int -> t -> t
val concat : t -> t -> t
val ( @. ) : t -> t -> t
val succ : t -> t
val pred : t -> t
val nsucc : t -> int -> t
val npred : t -> int -> t
val ( ++ ) : t -> int -> t
val ( -- ) : t -> int -> t
val gcd : t -> t -> t Core_kernel.Std.Or_error.t
val lcm : t -> t -> t Core_kernel.Std.Or_error.t
val gcdext : t -> t -> (t * t * t) Core_kernel.Std.Or_error.t
val gcd_exn : t -> t -> t
val lcm_exn : t -> t -> t
val gcdext_exn : t -> t -> t * t * t
val enum_bytes : t -> endian -> t seq
val enum_chars : t -> endian -> char seq
val enum_bits : t -> endian -> bool seq
val validate_positive : t Core_kernel.Std.Validate.check
val validate_non_negative : t Core_kernel.Std.Validate.check
val validate_negative : t Core_kernel.Std.Validate.check
val validate_non_positive : t Core_kernel.Std.Validate.check
val is_positive : t -> bool
val is_non_negative : t -> bool
val is_negative : t -> bool
val is_non_positive : t -> bool
module Int_err :
sig
val ( !$ ) : t -> t Core_kernel.Std.Or_error.t
val i1 : t -> t Core_kernel.Std.Or_error.t
val i4 : t -> t Core_kernel.Std.Or_error.t
val i8 : t -> t Core_kernel.Std.Or_error.t
val i16 : t -> t Core_kernel.Std.Or_error.t
val i32 : t -> t Core_kernel.Std.Or_error.t
val i64 : t -> t Core_kernel.Std.Or_error.t
val int : int -> t -> t Core_kernel.Std.Or_error.t
val of_word_size :
Core_kernel.Std.Word_size.t ->
t -> t Core_kernel.Std.Or_error.t
type t = addr Core_kernel.Std.Or_error.t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
val ( >>= ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b Core_kernel.Std.Or_error.t) ->
'b Core_kernel.Std.Or_error.t
val ( >>| ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b) -> 'b Core_kernel.Std.Or_error.t
end
module Int_exn :
sig
type t = addr
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
module Unsafe :
sig
type t = addr
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
module Stable :
sig
module V1 :
sig
type nonrec t = t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module V2 :
sig
type nonrec t = t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
end
module Trie :
sig
module Big :
sig
module Bits :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = addr
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module Bytes :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = addr
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
end
module Little :
sig
module Bits :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = addr
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module Bytes :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = addr
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
end
end
val memref :
?disp:int ->
?index:int -> ?scale:Bap.Std.size -> Bap.Std.addr -> Bap.Std.addr
end
module Bil :
sig
module Types :
sig
type var
type cast = UNSIGNED | SIGNED | HIGH | LOW
val bin_cast : cast Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_cast : cast Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_cast__ :
(int -> cast) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_cast :
cast Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_cast : cast Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_cast : cast Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_cast :
cast Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_cast : Core_kernel.Std.Bin_prot.Shape.t
val compare_cast : cast -> cast -> int
val cast_of_sexp : Sexplib.Sexp.t -> cast
val sexp_of_cast : cast -> Sexplib.Sexp.t
type binop =
PLUS
| MINUS
| TIMES
| DIVIDE
| SDIVIDE
| MOD
| SMOD
| LSHIFT
| RSHIFT
| ARSHIFT
| AND
| OR
| XOR
| EQ
| NEQ
| LT
| LE
| SLT
| SLE
val bin_binop : binop Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_binop : binop Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_binop__ :
(int -> binop) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_binop :
binop Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_binop : binop Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_binop :
binop Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_binop :
binop Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_binop : Core_kernel.Std.Bin_prot.Shape.t
val compare_binop : binop -> binop -> int
val binop_of_sexp : Sexplib.Sexp.t -> binop
val sexp_of_binop : binop -> Sexplib.Sexp.t
type unop = NEG | NOT
val bin_unop : unop Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_unop : unop Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_unop__ :
(int -> unop) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_unop :
unop Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_unop : unop Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_unop : unop Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_unop :
unop Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_unop : Core_kernel.Std.Bin_prot.Shape.t
val compare_unop : unop -> unop -> int
val unop_of_sexp : Sexplib.Sexp.t -> unop
val sexp_of_unop : unop -> Sexplib.Sexp.t
type exp =
Load of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
Bap.Std.endian * Bap.Std.size
| Store of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.exp * Bap.Std.endian * Bap.Std.size
| BinOp of Bap.Std.Bil.Types.binop * Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.exp
| UnOp of Bap.Std.Bil.Types.unop * Bap.Std.Bil.Types.exp
| Var of Bap.Std.Bil.Types.var
| Int of Bap.Std.word
| Cast of Bap.Std.Bil.Types.cast * int *
Bap.Std.Bil.Types.exp
| Let of Bap.Std.Bil.Types.var * Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.exp
| Unknown of string * Bap.Std.Bil.Types.typ
| Ite of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.exp
| Extract of int * int * Bap.Std.Bil.Types.exp
| Concat of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp
and typ = Imm of int | Mem of Bap.Std.addr_size * Bap.Std.size
val bin_exp : exp Core_kernel.Std.Bin_prot.Type_class.t
val bin_typ : typ Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_exp : exp Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_exp__ :
(int -> exp) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_exp :
exp Core_kernel.Std.Bin_prot.Type_class.reader
val bin_read_typ : typ Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_typ__ :
(int -> typ) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_typ :
typ Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_exp : exp Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_exp : exp Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_exp :
exp Core_kernel.Std.Bin_prot.Type_class.writer
val bin_size_typ : typ Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_typ : typ Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_typ :
typ Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_exp : Core_kernel.Std.Bin_prot.Shape.t
val bin_shape_typ : Core_kernel.Std.Bin_prot.Shape.t
val compare_exp : exp -> exp -> int
val compare_typ : typ -> typ -> int
val exp_of_sexp : Sexplib.Sexp.t -> exp
val typ_of_sexp : Sexplib.Sexp.t -> typ
val sexp_of_exp : exp -> Sexplib.Sexp.t
val sexp_of_typ : typ -> Sexplib.Sexp.t
type stmt =
Move of Bap.Std.Bil.Types.var * Bap.Std.Bil.Types.exp
| Jmp of Bap.Std.Bil.Types.exp
| Special of string
| While of Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.stmt list
| If of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.stmt list *
Bap.Std.Bil.Types.stmt list
| CpuExn of int
val bin_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_stmt : stmt Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_stmt__ :
(int -> stmt) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_stmt :
stmt Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_stmt : stmt Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_stmt : stmt Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_stmt :
stmt Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_stmt : Core_kernel.Std.Bin_prot.Shape.t
val compare_stmt : stmt -> stmt -> int
val stmt_of_sexp : Sexplib.Sexp.t -> stmt
val sexp_of_stmt : stmt -> Sexplib.Sexp.t
end
type var = Types.var
type cast = Types.cast = UNSIGNED | SIGNED | HIGH | LOW
val bin_cast : cast Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_cast : cast Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_cast__ :
(int -> cast) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_cast :
cast Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_cast : cast Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_cast : cast Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_cast :
cast Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_cast : Core_kernel.Std.Bin_prot.Shape.t
val compare_cast : cast -> cast -> int
val cast_of_sexp : Sexplib.Sexp.t -> cast
val sexp_of_cast : cast -> Sexplib.Sexp.t
type binop =
Types.binop =
PLUS
| MINUS
| TIMES
| DIVIDE
| SDIVIDE
| MOD
| SMOD
| LSHIFT
| RSHIFT
| ARSHIFT
| AND
| OR
| XOR
| EQ
| NEQ
| LT
| LE
| SLT
| SLE
val bin_binop : binop Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_binop : binop Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_binop__ :
(int -> binop) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_binop :
binop Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_binop : binop Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_binop : binop Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_binop :
binop Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_binop : Core_kernel.Std.Bin_prot.Shape.t
val compare_binop : binop -> binop -> int
val binop_of_sexp : Sexplib.Sexp.t -> binop
val sexp_of_binop : binop -> Sexplib.Sexp.t
type unop = Types.unop = NEG | NOT
val bin_unop : unop Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_unop : unop Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_unop__ :
(int -> unop) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_unop :
unop Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_unop : unop Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_unop : unop Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_unop :
unop Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_unop : Core_kernel.Std.Bin_prot.Shape.t
val compare_unop : unop -> unop -> int
val unop_of_sexp : Sexplib.Sexp.t -> unop
val sexp_of_unop : unop -> Sexplib.Sexp.t
type exp =
Types.exp =
Load of exp * exp * endian * size
| Store of exp * exp * exp * endian * size
| BinOp of binop * exp * exp
| UnOp of unop * exp
| Var of var
| Int of word
| Cast of cast * int * exp
| Let of var * exp * exp
| Unknown of Trie.String.Suffix.key * typ
| Ite of exp * exp * exp
| Extract of int * int * exp
| Concat of exp * exp
and typ = Types.typ = Imm of int | Mem of addr_size * size
val bin_exp : exp Core_kernel.Std.Bin_prot.Type_class.t
val bin_typ : typ Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_exp : exp Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_exp__ :
(int -> exp) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_exp : exp Core_kernel.Std.Bin_prot.Type_class.reader
val bin_read_typ : typ Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_typ__ :
(int -> typ) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_typ : typ Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_exp : exp Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_exp : exp Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_exp : exp Core_kernel.Std.Bin_prot.Type_class.writer
val bin_size_typ : typ Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_typ : typ Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_typ : typ Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_exp : Core_kernel.Std.Bin_prot.Shape.t
val bin_shape_typ : Core_kernel.Std.Bin_prot.Shape.t
val compare_exp : exp -> exp -> int
val compare_typ : typ -> typ -> int
val exp_of_sexp : Sexplib.Sexp.t -> exp
val typ_of_sexp : Sexplib.Sexp.t -> typ
val sexp_of_exp : exp -> Sexplib.Sexp.t
val sexp_of_typ : typ -> Sexplib.Sexp.t
type stmt =
Types.stmt =
Move of var * exp
| Jmp of exp
| Special of Trie.String.Suffix.key
| While of exp * stmt list
| If of exp * stmt list * stmt list
| CpuExn of int
val bin_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_stmt : stmt Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_stmt__ :
(int -> stmt) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_stmt :
stmt Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_stmt : stmt Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_stmt : stmt Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_stmt :
stmt Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_stmt : Core_kernel.Std.Bin_prot.Shape.t
val compare_stmt : stmt -> stmt -> int
val stmt_of_sexp : Sexplib.Sexp.t -> stmt
val sexp_of_stmt : stmt -> Sexplib.Sexp.t
type t = stmt list
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type var_compare
type vars = (var, Bap.Std.Bil.var_compare) Core_kernel.Std.Set.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val pp_binop : binop Regular.Std.printer
val pp_unop : unop Regular.Std.printer
val pp_cast : cast Regular.Std.printer
val string_of_binop : binop -> string
val string_of_unop : unop -> string
val string_of_cast : cast -> string
module Infix :
sig
val ( := ) : var -> exp -> stmt
val ( + ) : exp -> exp -> exp
val ( - ) : exp -> exp -> exp
val ( * ) : exp -> exp -> exp
val ( / ) : exp -> exp -> exp
val ( /$ ) : exp -> exp -> exp
val ( mod ) : exp -> exp -> exp
val ( %$ ) : exp -> exp -> exp
val ( lsl ) : exp -> exp -> exp
val ( lsr ) : exp -> exp -> exp
val ( asr ) : exp -> exp -> exp
val ( land ) : exp -> exp -> exp
val ( lor ) : exp -> exp -> exp
val ( lxor ) : exp -> exp -> exp
val lnot : exp -> exp
val ( = ) : exp -> exp -> exp
val ( <> ) : exp -> exp -> exp
val ( < ) : exp -> exp -> exp
val ( > ) : exp -> exp -> exp
val ( <= ) : exp -> exp -> exp
val ( >= ) : exp -> exp -> exp
val ( <$ ) : exp -> exp -> exp
val ( >$ ) : exp -> exp -> exp
val ( <=$ ) : exp -> exp -> exp
val ( >=$ ) : exp -> exp -> exp
val ( ^ ) : exp -> exp -> exp
end
val ( := ) : var -> exp -> stmt
val ( + ) : exp -> exp -> exp
val ( - ) : exp -> exp -> exp
val ( * ) : exp -> exp -> exp
val ( / ) : exp -> exp -> exp
val ( /$ ) : exp -> exp -> exp
val ( mod ) : exp -> exp -> exp
val ( %$ ) : exp -> exp -> exp
val ( lsl ) : exp -> exp -> exp
val ( lsr ) : exp -> exp -> exp
val ( asr ) : exp -> exp -> exp
val ( land ) : exp -> exp -> exp
val ( lor ) : exp -> exp -> exp
val ( lxor ) : exp -> exp -> exp
val lnot : exp -> exp
val ( = ) : exp -> exp -> exp
val ( <> ) : exp -> exp -> exp
val ( < ) : exp -> exp -> exp
val ( > ) : exp -> exp -> exp
val ( <= ) : exp -> exp -> exp
val ( >= ) : exp -> exp -> exp
val ( <$ ) : exp -> exp -> exp
val ( >$ ) : exp -> exp -> exp
val ( <=$ ) : exp -> exp -> exp
val ( >=$ ) : exp -> exp -> exp
val ( ^ ) : exp -> exp -> exp
val move : var -> exp -> stmt
val jmp : exp -> stmt
val special : string -> stmt
val while_ : exp -> stmt list -> stmt
val if_ : exp -> stmt list -> stmt list -> stmt
val cpuexn : int -> stmt
val unsigned : cast
val signed : cast
val high : cast
val low : cast
val plus : binop
val minus : binop
val times : binop
val divide : binop
val sdivide : binop
val modulo : binop
val smodulo : binop
val lshift : binop
val rshift : binop
val arshift : binop
val bit_and : binop
val bit_or : binop
val bit_xor : binop
val eq : binop
val neq : binop
val lt : binop
val le : binop
val slt : binop
val sle : binop
val neg : unop
val not : unop
val load :
mem:exp -> addr:exp -> Bap.Std.endian -> Bap.Std.size -> exp
val store :
mem:exp ->
addr:exp -> exp -> Bap.Std.endian -> Bap.Std.size -> exp
val binop : binop -> exp -> exp -> exp
val unop : unop -> exp -> exp
val var : var -> exp
val int : Bap.Std.word -> exp
val cast : cast -> int -> exp -> exp
val let_ : var -> exp -> exp -> exp
val unknown : string -> typ -> exp
val ite : if_:exp -> then_:exp -> else_:exp -> exp
val extract : hi:int -> lo:int -> exp -> exp
val concat : exp -> exp -> exp
val is_referenced : var -> stmt list -> bool
val is_assigned : ?strict:bool -> var -> stmt list -> bool
val prune_unreferenced :
?such_that:(var -> bool) ->
?physicals:bool -> ?virtuals:bool -> stmt list -> stmt list
val normalize_negatives : stmt list -> stmt list
val substitute : exp -> exp -> stmt list -> stmt list
val substitute_var : var -> exp -> stmt list -> stmt list
val free_vars : stmt list -> Bap.Std.Bil.vars
val fold_consts : stmt list -> stmt list
val fixpoint : (stmt list -> stmt list) -> stmt list -> stmt list
val propagate_consts : stmt list -> stmt list
val prune_dead_virtuals : stmt list -> stmt list
module Apply :
sig
val binop :
binop -> Bap.Std.word -> Bap.Std.word -> Bap.Std.word
val unop : unop -> Bap.Std.word -> Bap.Std.word
val cast : cast -> int -> Bap.Std.word -> Bap.Std.word
end
type result
class type storage =
object ('a)
method load : Bap.Std.addr -> Bap.Std.word option
method save : Bap.Std.addr -> Bap.Std.word -> 'a
end
module Storage :
sig class linear : storage class sparse : storage end
type value = Imm of Bap.Std.word | Mem of Bap.Std.Bil.storage | Bot
module Result :
sig
type id
type t = Bap.Std.Bil.result
type 'a r = (Bap.Std.Bil.result, 'a) Monads.Std.Monad.State.t
type 'a u = (unit, 'a) Monads.Std.Monad.State.t
val undefined : Bap.Std.Bil.Result.id -> Bap.Std.Bil.Result.t
val storage :
Bap.Std.Bil.storage ->
Bap.Std.Bil.Result.id -> Bap.Std.Bil.Result.t
val word :
Bap.Std.word -> Bap.Std.Bil.Result.id -> Bap.Std.Bil.Result.t
val id : Bap.Std.Bil.Result.t -> Bap.Std.Bil.Result.id
val value : Bap.Std.Bil.Result.t -> Bap.Std.Bil.value
module Id :
sig
type t = id
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = id
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(id, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : id -> 'a -> 'a t
val of_alist :
(id * 'a) list ->
[ `Duplicate_key of id | `Ok of 'a t ]
val of_alist_or_error :
(id * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (id * 'a) list -> 'a t
val of_alist_multi : (id * 'a) list -> 'a list t
val of_alist_fold :
(id * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(id * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(id * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(id * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> id * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:id -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of id | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:id -> data:'a -> 'a t
val add_multi :
'a list t -> key:id -> data:'a -> 'a list t
val remove_multi : 'a list t -> id -> 'a list t
val change :
'a t -> id -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> id -> f:('a option -> 'a) -> 'a t
val find : 'a t -> id -> 'a option
val find_exn : 'a t -> id -> 'a
val remove : 'a t -> id -> 'a t
val mem : 'a t -> id -> bool
val iter_keys : 'a t -> f:(id -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:id -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:id -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(id -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:id -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:id -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:id ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:id -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> id list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (id * 'a) list
val validate :
name:(id -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:id ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(id, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (id * 'a) option
val min_elt_exn : 'a t -> id * 'a
val max_elt : 'a t -> (id * 'a) option
val max_elt_exn : 'a t -> id * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:id -> data:'a -> bool) -> int
val split :
'a t -> id -> 'a t * (id * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:id Base__.Maybe_bound.t ->
upper_bound:id Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:id ->
max:id ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:id -> max:id -> (id * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> id -> (id * 'a) option
val nth : 'a t -> int -> (id * 'a) option
val nth_exn : 'a t -> int -> id * 'a
val rank : 'a t -> id -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:id ->
?keys_less_or_equal_to:id ->
'a t -> (id * 'a) Base__.Sequence.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> id
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(id, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : id -> 'a -> 'a t
val of_alist :
(id * 'a) list ->
[ `Duplicate_key of id | `Ok of 'a t ]
val of_alist_or_error :
(id * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (id * 'a) list -> 'a t
val of_alist_multi : (id * 'a) list -> 'a list t
val of_alist_fold :
(id * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(id * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(id * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (id * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> id * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:id -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of id | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:id -> data:'a -> 'a t
val add_multi :
'a list t -> key:id -> data:'a -> 'a list t
val remove_multi : 'a list t -> id -> 'a list t
val change :
'a t -> id -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> id -> f:('a option -> 'a) -> 'a t
val find : 'a t -> id -> 'a option
val find_exn : 'a t -> id -> 'a
val remove : 'a t -> id -> 'a t
val mem : 'a t -> id -> bool
val iter_keys : 'a t -> f:(id -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:id -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:id -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(id -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:id -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:id -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:id -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:id -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> id list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (id * 'a) list
val validate :
name:(id -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:id ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(id, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (id * 'a) option
val min_elt_exn : 'a t -> id * 'a
val max_elt : 'a t -> (id * 'a) option
val max_elt_exn : 'a t -> id * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:id -> data:'a -> bool) -> int
val split :
'a t -> id -> 'a t * (id * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:id Base__.Maybe_bound.t ->
upper_bound:id Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:id ->
max:id ->
init:'b -> f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:id -> max:id -> (id * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> id -> (id * 'a) option
val nth : 'a t -> int -> (id * 'a) option
val nth_exn : 'a t -> int -> id * 'a
val rank : 'a t -> id -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:id ->
?keys_less_or_equal_to:id ->
'a t -> (id * 'a) Base__.Sequence.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> id end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : id Bin_prot.Type_class.t
val bin_read_t : id Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> id)
Bin_prot.Read.reader
val bin_reader_t :
id Bin_prot.Type_class.reader
val bin_size_t : id Bin_prot.Size.sizer
val bin_write_t : id Bin_prot.Write.writer
val bin_writer_t :
id Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
id -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = id
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(id, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(id -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> id -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(id -> bool) -> bool
val for_all : t -> f:(id -> bool) -> bool
val count : t -> f:(id -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(id -> 'sum) -> 'sum
val find : t -> f:(id -> bool) -> id option
val find_map :
t -> f:(id -> 'a option) -> 'a option
val to_list : t -> id list
val to_array : t -> id array
val invariants : t -> bool
val mem : t -> id -> bool
val add : t -> id -> t
val remove : t -> id -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (id, id) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
id ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(id -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of id * id
| `Left of id
| `Right of id ] -> unit) ->
unit
val filter : t -> f:(id -> bool) -> t
val partition_tf : t -> f:(id -> bool) -> t * t
val elements : t -> id list
val min_elt : t -> id option
val min_elt_exn : t -> id
val max_elt : t -> id option
val max_elt_exn : t -> id
val choose : t -> id option
val choose_exn : t -> id
val split : t -> id -> t * id option * t
val group_by :
t -> equiv:(id -> id -> bool) -> t list
val find_exn : t -> f:(id -> bool) -> id
val find_index : t -> int -> id option
val nth : t -> int -> id option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id -> t -> id Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t ->
t ->
(id, id)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(id -> 'data) ->
(id, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : id -> t
val union_list : t list -> t
val of_list : id list -> t
val of_array : id array -> t
val of_sorted_array :
id array -> t Base__.Or_error.t
val of_sorted_array_unchecked : id array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> id) -> t
val stable_dedup_list : id list -> id list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> id) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> id option) -> t
val of_tree : t -> t
val of_hash_set : id Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(id, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(id, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> id
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (id, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(id -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> id -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(id -> bool) -> bool
val for_all : t -> f:(id -> bool) -> bool
val count : t -> f:(id -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(id -> 'sum) -> 'sum
val find : t -> f:(id -> bool) -> id option
val find_map : t -> f:(id -> 'a option) -> 'a option
val to_list : t -> id list
val to_array : t -> id array
val invariants : t -> bool
val mem : t -> id -> bool
val add : t -> id -> t
val remove : t -> id -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (id, id) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
id ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(id -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of id * id | `Left of id | `Right of id ] ->
unit) ->
unit
val filter : t -> f:(id -> bool) -> t
val partition_tf : t -> f:(id -> bool) -> t * t
val elements : t -> id list
val min_elt : t -> id option
val min_elt_exn : t -> id
val max_elt : t -> id option
val max_elt_exn : t -> id
val choose : t -> id option
val choose_exn : t -> id
val split : t -> id -> t * id option * t
val group_by : t -> equiv:(id -> id -> bool) -> t list
val find_exn : t -> f:(id -> bool) -> id
val find_index : t -> int -> id option
val nth : t -> int -> id option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id -> t -> id Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t ->
t ->
(id, id)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(id -> 'data) ->
(id, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : id -> t
val union_list : t list -> t
val of_list : id list -> t
val of_array : id array -> t
val of_sorted_array : id array -> t Base__.Or_error.t
val of_sorted_array_unchecked : id array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> id) -> t
val stable_dedup_list : id list -> id list
val map : ('a, 'b) Base.Set.t -> f:('a -> id) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> id option) -> t
val of_tree : Tree.t -> t
val of_hash_set : id Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(id, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(id, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> id end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : id Bin_prot.Type_class.t
val bin_read_t : id Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> id)
Bin_prot.Read.reader
val bin_reader_t :
id Bin_prot.Type_class.reader
val bin_size_t : id Bin_prot.Size.sizer
val bin_write_t : id Bin_prot.Write.writer
val bin_writer_t :
id Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
id -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Addr.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = id
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> id -> Core_kernel__.Import.bool
val lookup :
'a t -> id -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> id -> 'a
val enqueue :
'a t -> id -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> id -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> id -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> id -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (id * 'a) Core_kernel__.Import.option
val keys : 'a t -> id Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (id * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> id * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> id -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> id -> Core_kernel__.Import.unit
val replace :
'a t -> id -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> id -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:id -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:id -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key *
[ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t ->
(unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val zero : Bap.Std.Bil.Result.t
val succ : Bap.Std.Bil.Result.t -> Bap.Std.Bil.Result.t
end
module Value :
sig
type t = value
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
module Trie :
sig
type normalized_bil
val normalize :
?subst:(exp * exp) list ->
stmt list -> Bap.Std.Bil.Trie.normalized_bil
module Normalized :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = normalized_bil
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = stmt list
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change : 'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
type pass
val register_pass :
?desc:string ->
string -> (Bap.Std.Bil.t -> Bap.Std.Bil.t) -> Bap.Std.Bil.pass
val select_passes : Bap.Std.Bil.pass list -> unit
val passes : unit -> Bap.Std.Bil.pass list
module Pass :
sig
val name : Bap.Std.Bil.pass -> string
val to_string : pass -> string
val str : unit -> pass -> string
val pps : unit -> pass -> string
val ppo : Core_kernel.Std.Out_channel.t -> pass -> unit
val pp_seq : Format.formatter -> pass Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> pass -> unit
end
end
type typ = Bap.Std.Bil.typ
val bin_typ : typ Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_typ : typ Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_typ__ :
(int -> typ) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_typ : typ Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_typ : typ Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_typ : typ Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_typ : typ Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_typ : Core_kernel.Std.Bin_prot.Shape.t
val compare_typ : typ -> typ -> int
val typ_of_sexp : Sexplib.Sexp.t -> typ
val sexp_of_typ : typ -> Sexplib.Sexp.t
type var = Bap.Std.Bil.var
val bin_var : var Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_var : var Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_var__ :
(int -> var) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_var : var Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_var : var Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_var : var Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_var : var Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_var : Core_kernel.Std.Bin_prot.Shape.t
val compare_var : var -> var -> int
val var_of_sexp : Sexplib.Sexp.t -> var
val sexp_of_var : var -> Sexplib.Sexp.t
type bil = Bap.Std.Bil.t
val bin_bil : bil Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_bil : bil Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_bil__ :
(int -> bil) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_bil : bil Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_bil : bil Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_bil : bil Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_bil : bil Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_bil : Core_kernel.Std.Bin_prot.Shape.t
val compare_bil : bil -> bil -> int
val bil_of_sexp : Sexplib.Sexp.t -> bil
val sexp_of_bil : bil -> Sexplib.Sexp.t
type binop = Bap.Std.Bil.binop
val bin_binop : binop Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_binop : binop Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_binop__ :
(int -> binop) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_binop : binop Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_binop : binop Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_binop : binop Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_binop : binop Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_binop : Core_kernel.Std.Bin_prot.Shape.t
val compare_binop : binop -> binop -> int
val binop_of_sexp : Sexplib.Sexp.t -> binop
val sexp_of_binop : binop -> Sexplib.Sexp.t
type cast = Bap.Std.Bil.cast
val bin_cast : cast Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_cast : cast Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_cast__ :
(int -> cast) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_cast : cast Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_cast : cast Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_cast : cast Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_cast : cast Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_cast : Core_kernel.Std.Bin_prot.Shape.t
val compare_cast : cast -> cast -> int
val cast_of_sexp : Sexplib.Sexp.t -> cast
val sexp_of_cast : cast -> Sexplib.Sexp.t
type exp = Bap.Std.Bil.exp
val bin_exp : exp Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_exp : exp Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_exp__ :
(int -> exp) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_exp : exp Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_exp : exp Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_exp : exp Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_exp : exp Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_exp : Core_kernel.Std.Bin_prot.Shape.t
val compare_exp : exp -> exp -> int
val exp_of_sexp : Sexplib.Sexp.t -> exp
val sexp_of_exp : exp -> Sexplib.Sexp.t
type stmt = Bap.Std.Bil.stmt
val bin_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_stmt : stmt Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_stmt__ :
(int -> stmt) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_stmt : stmt Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_stmt : stmt Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_stmt : Core_kernel.Std.Bin_prot.Shape.t
val compare_stmt : stmt -> stmt -> int
val stmt_of_sexp : Sexplib.Sexp.t -> stmt
val sexp_of_stmt : stmt -> Sexplib.Sexp.t
type unop = Bap.Std.Bil.unop
val bin_unop : unop Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_unop : unop Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_unop__ :
(int -> unop) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_unop : unop Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_unop : unop Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_unop : unop Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_unop : unop Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_unop : Core_kernel.Std.Bin_prot.Shape.t
val compare_unop : unop -> unop -> int
val unop_of_sexp : Sexplib.Sexp.t -> unop
val sexp_of_unop : unop -> Sexplib.Sexp.t
module Type :
sig
type t =
Bap.Std.Bil.typ =
Imm of int
| Mem of Bap.Std.addr_size * Bap.Std.size
module Variants :
sig
val imm : (int -> t) Variantslib.Variant.t
val mem : (addr_size -> size -> t) Variantslib.Variant.t
val fold :
init:'acc__ ->
imm:('acc__ -> (int -> t) Variantslib.Variant.t -> 'acc__) ->
mem:('acc__ ->
(addr_size -> size -> t) Variantslib.Variant.t -> 'acc__) ->
'acc__
val iter :
imm:((int -> t) Variantslib.Variant.t -> unit) ->
mem:((addr_size -> size -> t) Variantslib.Variant.t -> unit) ->
unit
val map :
t ->
imm:((int -> t) Variantslib.Variant.t -> int -> 'result__) ->
mem:((addr_size -> size -> t) Variantslib.Variant.t ->
addr_size -> size -> 'result__) ->
'result__
val to_rank : t -> int
val to_name : t -> Trie.String.Suffix.key
val descriptions : (Trie.String.Suffix.key * int) list
end
type error
val bin_error : error Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_error : error Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_error__ :
(int -> error) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_error :
error Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_error : error Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_error : error Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_error :
error Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_error : Core_kernel.Std.Bin_prot.Shape.t
val compare_error : error -> error -> int
val error_of_sexp : Sexplib.Sexp.t -> error
val sexp_of_error : error -> Sexplib.Sexp.t
val imm : int -> Bap.Std.Type.t
val mem : Bap.Std.addr_size -> Bap.Std.size -> Bap.Std.Type.t
val infer :
Bap.Std.exp ->
(Bap.Std.Type.t, Bap.Std.Type.error) Core_kernel.Std.Result.t
val infer_exn : Bap.Std.exp -> Bap.Std.Type.t
val check :
Bap.Std.bil ->
(unit, Bap.Std.Type.error) Core_kernel.Std.Result.t
module Error :
sig
type t = Bap.Std.Type.error
exception T of Bap.Std.Type.Error.t
val bad_mem : Bap.Std.Type.Error.t
val bad_imm : Bap.Std.Type.Error.t
val bad_cast : Bap.Std.Type.Error.t
val bad_type :
exp:Bap.Std.typ -> got:Bap.Std.typ -> Bap.Std.Type.Error.t
val expect_mem : unit -> 'a
val expect_imm : unit -> 'a
val wrong_cast : unit -> 'a
val expect : Bap.Std.typ -> got:Bap.Std.typ -> 'a
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.Type.error
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Addr.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key *
[ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t ->
(unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.Bil.typ
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Error.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
val bool_t : Bap.Std.typ
val reg8_t : Bap.Std.typ
val reg16_t : Bap.Std.typ
val reg32_t : Bap.Std.typ
val reg64_t : Bap.Std.typ
val reg128_t : Bap.Std.typ
val reg256_t : Bap.Std.typ
val mem32_t : Bap.Std.size -> Bap.Std.typ
val mem64_t : Bap.Std.size -> Bap.Std.typ
module Var :
sig
type t = Bap.Std.var
val create :
?is_virtual:bool ->
?fresh:bool -> string -> Bap.Std.typ -> Bap.Std.Var.t
val name : Bap.Std.Var.t -> string
val typ : Bap.Std.Var.t -> Bap.Std.typ
val is_physical : Bap.Std.Var.t -> bool
val is_virtual : Bap.Std.Var.t -> bool
val with_index : Bap.Std.Var.t -> int -> Bap.Std.Var.t
val index : Bap.Std.Var.t -> int
val base : Bap.Std.Var.t -> Bap.Std.Var.t
val same : Bap.Std.Var.t -> Bap.Std.Var.t -> bool
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness = Bil.var_compare
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.var
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Bil.var_compare
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Bil.var_compare
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Type.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Context :
sig
class t :
object ('a)
method bindings :
(Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
method lookup : Bap.Std.var -> Bap.Std.Bil.result option
method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
end
end
module Type_error :
sig
type t = Type.Error.t
exception T of t
val bad_mem : t
val bad_imm : t
val bad_cast : t
val bad_type : exp:typ -> got:typ -> t
val expect_mem : unit -> 'a
val expect_imm : unit -> 'a
val wrong_cast : unit -> 'a
val expect : typ -> got:typ -> 'a
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Type.Error.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Var.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
type type_error = Bap.Std.Type_error.t
val bin_type_error : type_error Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_type_error :
type_error Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_type_error__ :
(int -> type_error) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_type_error :
type_error Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_type_error :
type_error Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_type_error :
type_error Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_type_error :
type_error Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_type_error : Core_kernel.Std.Bin_prot.Shape.t
val compare_type_error : type_error -> type_error -> int
val type_error_of_sexp : Sexplib.Sexp.t -> type_error
val sexp_of_type_error : type_error -> Sexplib.Sexp.t
module Eval :
sig
module T1 :
functor (M : Core_kernel.Std.T1) ->
sig
type 'a m = 'a M.t
class type ['r] semantics =
object
method eval_binop :
Bap.Std.binop ->
Bap.Std.exp -> Bap.Std.exp -> 'r Bap.Std.Eval.T1.m
method eval_cast :
Bap.Std.cast ->
int -> Bap.Std.exp -> 'r Bap.Std.Eval.T1.m
method eval_concat :
Bap.Std.exp -> Bap.Std.exp -> 'r Bap.Std.Eval.T1.m
method eval_exp : Bap.Std.exp -> 'r Bap.Std.Eval.T1.m
method eval_extract :
int -> int -> Bap.Std.exp -> 'r Bap.Std.Eval.T1.m
method eval_int : Bap.Std.word -> 'r Bap.Std.Eval.T1.m
method eval_ite :
cond:Bap.Std.exp ->
yes:Bap.Std.exp ->
no:Bap.Std.exp -> 'r Bap.Std.Eval.T1.m
method eval_let :
Bap.Std.var ->
Bap.Std.exp -> Bap.Std.exp -> 'r Bap.Std.Eval.T1.m
method eval_load :
mem:Bap.Std.exp ->
addr:Bap.Std.exp ->
Bap.Std.endian -> Bap.Std.size -> 'r Bap.Std.Eval.T1.m
method eval_store :
mem:Bap.Std.exp ->
addr:Bap.Std.exp ->
Bap.Std.exp ->
Bap.Std.endian -> Bap.Std.size -> 'r Bap.Std.Eval.T1.m
method eval_unknown :
string -> Bap.Std.typ -> 'r Bap.Std.Eval.T1.m
method eval_unop :
Bap.Std.unop -> Bap.Std.exp -> 'r Bap.Std.Eval.T1.m
method eval_var : Bap.Std.var -> 'r Bap.Std.Eval.T1.m
end
class type virtual ['r, 's] domain =
object
method private virtual storage_of_value :
'r -> 's option Bap.Std.Eval.T1.m
method private virtual undefined : 'r Bap.Std.Eval.T1.m
method private virtual value_of_word :
Bap.Std.word -> 'r Bap.Std.Eval.T1.m
method private virtual word_of_value :
'r -> Bap.Std.word option Bap.Std.Eval.T1.m
end
class type virtual ['r, 's] eff =
object
method virtual load :
's -> Bap.Std.addr -> 'r Bap.Std.Eval.T1.m
method virtual lookup :
Bap.Std.var -> 'r Bap.Std.Eval.T1.m
method virtual store :
's ->
Bap.Std.addr -> Bap.Std.word -> 'r Bap.Std.Eval.T1.m
method virtual update :
Bap.Std.var -> 'r -> unit Bap.Std.Eval.T1.m
end
end
module T2 :
functor (M : Core_kernel.Std.T2) ->
sig
type ('a, 'e) m = ('a, 'e) M.t
class type ['a, 'r] semantics =
object
method eval_binop :
Bap.Std.binop ->
Bap.Std.exp ->
Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_cast :
Bap.Std.cast ->
int -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_concat :
Bap.Std.exp ->
Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_exp :
Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_extract :
int -> int -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_int :
Bap.Std.word -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_ite :
cond:Bap.Std.exp ->
yes:Bap.Std.exp ->
no:Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_let :
Bap.Std.var ->
Bap.Std.exp ->
Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_load :
mem:Bap.Std.exp ->
addr:Bap.Std.exp ->
Bap.Std.endian ->
Bap.Std.size -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_store :
mem:Bap.Std.exp ->
addr:Bap.Std.exp ->
Bap.Std.exp ->
Bap.Std.endian ->
Bap.Std.size -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_unknown :
string -> Bap.Std.typ -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_unop :
Bap.Std.unop ->
Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
method eval_var :
Bap.Std.var -> ('r, 'a) Bap.Std.Eval.T2.m
end
class type virtual ['a, 'r, 's] domain =
object
method private virtual storage_of_value :
'r -> ('s option, 'a) Bap.Std.Eval.T2.m
method private virtual undefined :
('r, 'a) Bap.Std.Eval.T2.m
method private virtual value_of_word :
Bap.Std.word -> ('r, 'a) Bap.Std.Eval.T2.m
method private virtual word_of_value :
'r -> (Bap.Std.word option, 'a) Bap.Std.Eval.T2.m
end
class type virtual ['a, 'r, 's] eff =
object
method virtual load :
's -> Bap.Std.addr -> ('r, 'a) Bap.Std.Eval.T2.m
method virtual lookup :
Bap.Std.var -> ('r, 'a) Bap.Std.Eval.T2.m
method virtual store :
's ->
Bap.Std.addr ->
Bap.Std.word -> ('r, 'a) Bap.Std.Eval.T2.m
method virtual update :
Bap.Std.var -> 'r -> (unit, 'a) Bap.Std.Eval.T2.m
end
end
module type S =
sig
type 'a m
module M : sig type 'a t = 'a m end
class type ['r] semantics = ['r] T1(M).semantics
class type virtual ['r, 's] domain = ['r, 's] T1(M).domain
class type virtual ['r, 's] eff = ['r, 's] T1(M).eff
class virtual ['r, 's] t :
object
method division_by_zero : unit -> 'r Bap.Std.Eval.S.m
method eval_binop : binop -> exp -> exp -> 'r M.t
method eval_cast : cast -> int -> exp -> 'r M.t
method eval_concat : exp -> exp -> 'r M.t
method eval_exp : exp -> 'r M.t
method eval_extract : int -> int -> exp -> 'r M.t
method eval_int : word -> 'r M.t
method eval_ite : cond:exp -> yes:exp -> no:exp -> 'r M.t
method eval_let : var -> exp -> exp -> 'r M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> 'r M.t
method eval_store :
mem:exp -> addr:exp -> exp -> endian -> size -> 'r M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> 'r M.t
method eval_unop : unop -> exp -> 'r M.t
method eval_var : var -> 'r M.t
method virtual load : 's -> addr -> 'r M.t
method virtual lookup : var -> 'r M.t
method private virtual storage_of_value :
'r -> 's option M.t
method virtual store : 's -> addr -> word -> 'r M.t
method type_error :
Bap.Std.type_error -> 'r Bap.Std.Eval.S.m
method private virtual undefined : 'r M.t
method virtual update : var -> 'r -> unit M.t
method private virtual value_of_word : word -> 'r M.t
method private virtual word_of_value :
'r -> word option M.t
end
end
module type S2 =
sig
type ('a, 'e) m
module M : sig type ('a, 'e) t = ('a, 'e) m end
class type ['a, 'r] semantics = ['a, 'r] T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] T2(M).domain
class type virtual ['a, 'r, 's] eff = ['a, 'r, 's] T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero :
unit -> ('r, 'a) Bap.Std.Eval.S2.m
method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract : int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store : 's -> addr -> word -> ('r, 'a) M.t
method type_error :
Bap.Std.type_error -> ('r, 'a) Bap.Std.Eval.S2.m
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word : word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
module Make2 :
functor (M : Monads.Std.Monad.S2) ->
sig
class type ['a, 'r] semantics = ['a, 'r] T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] T2(M).domain
class type virtual ['a, 'r, 's] eff = ['a, 'r, 's] T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) M.t
method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract : int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store : 's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) M.t
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
module Make :
functor (M : Monads.Std.Monad.S) ->
sig
class type ['r] semantics = ['r] T1(M).semantics
class type virtual ['r, 's] domain = ['r, 's] T1(M).domain
class type virtual ['r, 's] eff = ['r, 's] T1(M).eff
class virtual ['r, 's] t :
object
method division_by_zero : unit -> 'r M.t
method eval_binop : binop -> exp -> exp -> 'r M.t
method eval_cast : cast -> int -> exp -> 'r M.t
method eval_concat : exp -> exp -> 'r M.t
method eval_exp : exp -> 'r M.t
method eval_extract : int -> int -> exp -> 'r M.t
method eval_int : word -> 'r M.t
method eval_ite : cond:exp -> yes:exp -> no:exp -> 'r M.t
method eval_let : var -> exp -> exp -> 'r M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> 'r M.t
method eval_store :
mem:exp -> addr:exp -> exp -> endian -> size -> 'r M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> 'r M.t
method eval_unop : unop -> exp -> 'r M.t
method eval_var : var -> 'r M.t
method virtual load : 's -> addr -> 'r M.t
method virtual lookup : var -> 'r M.t
method private virtual storage_of_value :
'r -> 's option M.t
method virtual store : 's -> addr -> word -> 'r M.t
method type_error : type_error -> 'r M.t
method private virtual undefined : 'r M.t
method virtual update : var -> 'r -> unit M.t
method private virtual value_of_word : word -> 'r M.t
method private virtual word_of_value :
'r -> word option M.t
end
end
end
module Expi :
sig
class context :
object ('a)
method bindings :
(Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
method create_storage :
Bap.Std.Bil.storage -> 'a * Bap.Std.Bil.result
method create_undefined : 'a * Bap.Std.Bil.result
method create_word : Bap.Std.word -> 'a * Bap.Std.Bil.result
method lookup : Bap.Std.var -> Bap.Std.Bil.result option
method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
end
module type S =
sig
type ('a, 'e) state
type 'a u = (unit, 'a) Bap.Std.Expi.S.state
type 'a r = (Bap.Std.Bil.result, 'a) Bap.Std.Expi.S.state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract : int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Bap.Std.Expi.context
method division_by_zero : unit -> 'a Bap.Std.Expi.S.r
method empty : Bap.Std.Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load :
Bap.Std.Bil.storage ->
Bap.Std.addr -> 'a Bap.Std.Expi.S.r
method lookup : Bap.Std.var -> 'a Bap.Std.Expi.S.r
method store :
Bap.Std.Bil.storage ->
Bap.Std.addr -> Bap.Std.word -> 'a Bap.Std.Expi.S.r
method type_error :
Bap.Std.type_error -> 'a Bap.Std.Expi.S.r
method undefined_addr : Bap.Std.addr -> 'a Bap.Std.Expi.S.r
method undefined_var : Bap.Std.var -> 'a Bap.Std.Expi.S.r
method update :
Bap.Std.var -> Bap.Std.Bil.result -> 'a Bap.Std.Expi.S.u
end
end
module Make :
functor (M : Monads.Std.Monad.State.S2) ->
sig
type ('a, 'e) state = ('a, 'e) M.t
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop :
binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract :
int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
type ('a, 'e) state = ('a, 'e) Legacy.Monad.State.t
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics = ['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract : int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store : 's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word : word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] expi :
object
constraint 'a = #Bap.Std.Expi.context
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
module Bili :
sig
class context :
object ('a)
method bindings :
(Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
method create_storage :
Bap.Std.Bil.storage -> 'a * Bap.Std.Bil.result
method create_undefined : 'a * Bap.Std.Bil.result
method create_word : Bap.Std.word -> 'a * Bap.Std.Bil.result
method lookup : Bap.Std.var -> Bap.Std.Bil.result option
method pc : Bap.Std.Bil.value
method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
method with_pc : Bap.Std.Bil.value -> 'a
end
module type S =
sig
type ('a, 'e) state
type 'a u = (unit, 'a) Bap.Std.Bili.S.state
type 'a r = (Bap.Std.Bil.result, 'a) Bap.Std.Bili.S.state
module Expi :
sig
type ('a, 'e) state = ('a, 'e) state
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop :
binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast :
cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract :
int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Expi.context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] t :
object
constraint 'a = #Bap.Std.Bili.context
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method eval : Bap.Std.stmt list -> 'a Bap.Std.Bili.S.u
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_cpuexn : int -> 'a Bap.Std.Bili.S.u
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_if :
cond:Bap.Std.exp ->
yes:Bap.Std.stmt list ->
no:Bap.Std.stmt list -> 'a Bap.Std.Bili.S.u
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_jmp : Bap.Std.exp -> 'a Bap.Std.Bili.S.u
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_move :
Bap.Std.var -> Bap.Std.exp -> 'a Bap.Std.Bili.S.u
method eval_special : string -> 'a Bap.Std.Bili.S.u
method eval_stmt : Bap.Std.stmt -> 'a Bap.Std.Bili.S.u
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method eval_while :
cond:Bap.Std.exp ->
body:Bap.Std.stmt list -> 'a Bap.Std.Bili.S.u
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
end
module Make :
functor (M : Monads.Std.Monad.State.S2) ->
sig
type ('a, 'e) state = ('a, 'e) M.t
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module Expi :
sig
type ('a, 'e) state = ('a, 'e) M.t
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop :
binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast :
cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract :
int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let :
var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update :
var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Expi.context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat :
exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp ->
yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key ->
typ -> (Bil.result, 'a) M.t
method eval_unop :
unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] t :
object
constraint 'a = #context
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method eval : stmt list -> 'a u
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_cpuexn : int -> 'a u
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_if :
cond:exp -> yes:stmt list -> no:stmt list -> 'a u
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_jmp : exp -> 'a u
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_move : var -> exp -> 'a u
method eval_special : Trie.String.Suffix.key -> 'a u
method eval_stmt : stmt -> 'a u
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method eval_while : cond:exp -> body:stmt list -> 'a u
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
end
type ('a, 'e) state = ('a, 'e) Expi.state
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module Expi :
sig
type ('a, 'e) state = ('a, 'e) Expi.state
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract : int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Expi.context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] t :
object
constraint 'a = #context
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method eval : stmt list -> 'a u
method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_cpuexn : int -> 'a u
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
method eval_if :
cond:exp -> yes:stmt list -> no:stmt list -> 'a u
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_jmp : exp -> 'a u
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_move : var -> exp -> 'a u
method eval_special : Trie.String.Suffix.key -> 'a u
method eval_stmt : stmt -> 'a u
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method eval_while : cond:exp -> body:stmt list -> 'a u
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
end
class ['a] bili :
object
constraint 'a = #Bap.Std.Bili.context
method division_by_zero : unit -> 'a Bili.Expi.r
method empty : Bil.storage
method eval : stmt list -> 'a Bili.u
method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_cpuexn : int -> 'a Bili.u
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
method eval_if :
cond:exp -> yes:stmt list -> no:stmt list -> 'a Bili.u
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_jmp : exp -> 'a Bili.u
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_move : var -> exp -> 'a Bili.u
method eval_special : Trie.String.Suffix.key -> 'a Bili.u
method eval_stmt : stmt -> 'a Bili.u
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method eval_while : cond:exp -> body:stmt list -> 'a Bili.u
method load : Bil.storage -> addr -> 'a Bili.Expi.r
method lookup : var -> 'a Bili.Expi.r
method store : Bil.storage -> addr -> word -> 'a Bili.Expi.r
method type_error : type_error -> 'a Bili.Expi.r
method undefined_addr : addr -> 'a Bili.Expi.r
method undefined_var : var -> 'a Bili.Expi.r
method update : var -> Bil.result -> 'a Bili.Expi.u
end
module Eff :
sig
type t
val none : Bap.Std.Eff.t
val read : Bap.Std.Eff.t
val load : Bap.Std.Eff.t
val store : Bap.Std.Eff.t
val raise : Bap.Std.Eff.t
val reads : Bap.Std.Eff.t -> bool
val loads : Bap.Std.Eff.t -> bool
val stores : Bap.Std.Eff.t -> bool
val raises : Bap.Std.Eff.t -> bool
val has_effects : Bap.Std.Eff.t -> bool
val has_coeffects : Bap.Std.Eff.t -> bool
val compute : Bap.Std.exp -> Bap.Std.Eff.t
end
module Exp :
sig
type t = Bap.Std.Bil.exp
class state :
object
val exps_stack : Bap.Std.exp list
val under_condition : bool
end
class ['a] visitor :
object
val exps_stack : exp list
val under_condition : bool
method enter_binop :
Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> 'a -> 'a
method enter_cast :
Bap.Std.cast -> int -> Bap.Std.Exp.t -> 'a -> 'a
method enter_concat :
Bap.Std.Exp.t -> Bap.Std.Exp.t -> 'a -> 'a
method enter_exp : Bap.Std.Exp.t -> 'a -> 'a
method enter_extract :
hi:int -> lo:int -> Bap.Std.Exp.t -> 'a -> 'a
method enter_int : Bap.Std.word -> 'a -> 'a
method enter_ite :
cond:Bap.Std.Exp.t ->
yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> 'a -> 'a
method enter_let :
Bap.Std.var ->
exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> 'a -> 'a
method enter_load :
mem:Bap.Std.Exp.t ->
addr:Bap.Std.Exp.t ->
Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method enter_store :
mem:Bap.Std.Exp.t ->
addr:Bap.Std.Exp.t ->
exp:Bap.Std.Exp.t ->
Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method enter_unknown : string -> Bap.Std.typ -> 'a -> 'a
method enter_unop : Bap.Std.unop -> Bap.Std.Exp.t -> 'a -> 'a
method enter_var : Bap.Std.var -> 'a -> 'a
method leave_binop :
Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> 'a -> 'a
method leave_cast :
Bap.Std.cast -> int -> Bap.Std.Exp.t -> 'a -> 'a
method leave_concat :
Bap.Std.Exp.t -> Bap.Std.Exp.t -> 'a -> 'a
method leave_exp : Bap.Std.Exp.t -> 'a -> 'a
method leave_extract :
hi:int -> lo:int -> Bap.Std.Exp.t -> 'a -> 'a
method leave_int : Bap.Std.word -> 'a -> 'a
method leave_ite :
cond:Bap.Std.Exp.t ->
yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> 'a -> 'a
method leave_let :
Bap.Std.var ->
exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> 'a -> 'a
method leave_load :
mem:Bap.Std.Exp.t ->
addr:Bap.Std.Exp.t ->
Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method leave_store :
mem:Bap.Std.Exp.t ->
addr:Bap.Std.Exp.t ->
exp:Bap.Std.Exp.t ->
Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method leave_unknown : string -> Bap.Std.typ -> 'a -> 'a
method leave_unop : Bap.Std.unop -> Bap.Std.Exp.t -> 'a -> 'a
method leave_var : Bap.Std.var -> 'a -> 'a
method visit_binop :
Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> 'a -> 'a
method visit_cast :
Bap.Std.cast -> int -> Bap.Std.Exp.t -> 'a -> 'a
method visit_concat :
Bap.Std.Exp.t -> Bap.Std.Exp.t -> 'a -> 'a
method visit_exp : Bap.Std.Exp.t -> 'a -> 'a
method visit_extract :
hi:int -> lo:int -> Bap.Std.Exp.t -> 'a -> 'a
method visit_int : Bap.Std.word -> 'a -> 'a
method visit_ite :
cond:Bap.Std.Exp.t ->
yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> 'a -> 'a
method visit_let :
Bap.Std.var ->
exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> 'a -> 'a
method visit_load :
mem:Bap.Std.Exp.t ->
addr:Bap.Std.Exp.t ->
Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method visit_store :
mem:Bap.Std.Exp.t ->
addr:Bap.Std.Exp.t ->
exp:Bap.Std.Exp.t ->
Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method visit_unknown : string -> Bap.Std.typ -> 'a -> 'a
method visit_unop : Bap.Std.unop -> Bap.Std.Exp.t -> 'a -> 'a
method visit_var : Bap.Std.var -> 'a -> 'a
end
class ['a] finder :
object
val exps_stack : exp list
val under_condition : bool
method enter_binop :
binop ->
t ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_cast :
cast ->
int ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_concat :
t ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_exp :
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_extract :
hi:int ->
lo:int ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_int :
word ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_ite :
cond:t ->
yes:t ->
no:t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_let :
var ->
exp:t ->
body:t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_load :
mem:t ->
addr:t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_store :
mem:t ->
addr:t ->
exp:t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_unknown :
Trie.String.Suffix.key ->
typ ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_unop :
unop ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_var :
var ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method find : Bap.Std.Exp.t -> 'a option
method leave_binop :
binop ->
t ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_cast :
cast ->
int ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_concat :
t ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_exp :
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_extract :
hi:int ->
lo:int ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_int :
word ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_ite :
cond:t ->
yes:t ->
no:t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_let :
var ->
exp:t ->
body:t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_load :
mem:t ->
addr:t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_store :
mem:t ->
addr:t ->
exp:t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_unknown :
Trie.String.Suffix.key ->
typ ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_unop :
unop ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_var :
var ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_binop :
binop ->
t ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_cast :
cast ->
int ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_concat :
t ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_exp :
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_extract :
hi:int ->
lo:int ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_int :
word ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_ite :
cond:t ->
yes:t ->
no:t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_let :
var ->
exp:t ->
body:t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_load :
mem:t ->
addr:t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_store :
mem:t ->
addr:t ->
exp:t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_unknown :
Trie.String.Suffix.key ->
typ ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_unop :
unop ->
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_var :
var ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
end
class mapper :
object
val exps_stack : exp list
val under_condition : bool
method map_binop :
Bap.Std.binop ->
Bap.Std.Exp.t -> Bap.Std.Exp.t -> Bap.Std.Exp.t
method map_cast :
Bap.Std.cast -> int -> Bap.Std.Exp.t -> Bap.Std.Exp.t
method map_concat :
Bap.Std.Exp.t -> Bap.Std.Exp.t -> Bap.Std.Exp.t
method map_exp : Bap.Std.Exp.t -> Bap.Std.Exp.t
method map_extract :
hi:int -> lo:int -> Bap.Std.Exp.t -> Bap.Std.Exp.t
method map_int : Bap.Std.word -> Bap.Std.Exp.t
method map_ite :
cond:Bap.Std.Exp.t ->
yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> Bap.Std.Exp.t
method map_let :
Bap.Std.var ->
exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> Bap.Std.Exp.t
method map_load :
mem:Bap.Std.Exp.t ->
addr:Bap.Std.Exp.t ->
Bap.Std.endian -> Bap.Std.size -> Bap.Std.Exp.t
method map_store :
mem:Bap.Std.Exp.t ->
addr:Bap.Std.Exp.t ->
exp:Bap.Std.Exp.t ->
Bap.Std.endian -> Bap.Std.size -> Bap.Std.Exp.t
method map_sym : Bap.Std.var -> Bap.Std.var
method map_unknown : string -> Bap.Std.typ -> Bap.Std.Exp.t
method map_unop :
Bap.Std.unop -> Bap.Std.Exp.t -> Bap.Std.Exp.t
method map_var : Bap.Std.var -> Bap.Std.Exp.t
end
val fold :
'a #Bap.Std.Exp.visitor -> init:'a -> Bap.Std.Exp.t -> 'a
val iter : unit #Bap.Std.Exp.visitor -> Bap.Std.Exp.t -> unit
val find : 'a #Bap.Std.Exp.finder -> Bap.Std.Exp.t -> 'a option
val map : #Bap.Std.Exp.mapper -> Bap.Std.Exp.t -> Bap.Std.Exp.t
val exists : unit #Bap.Std.Exp.finder -> Bap.Std.Exp.t -> bool
val substitute :
Bap.Std.exp -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.exp
val normalize : Bap.Std.exp -> Bap.Std.exp
val simpl :
?ignore:Bap.Std.Eff.t list -> Bap.Std.exp -> Bap.Std.exp
val is_referenced : Bap.Std.var -> Bap.Std.Exp.t -> bool
val normalize_negatives : Bap.Std.Exp.t -> Bap.Std.Exp.t
val fold_consts : Bap.Std.Exp.t -> Bap.Std.Exp.t
val fixpoint :
(Bap.Std.Exp.t -> Bap.Std.Exp.t) ->
Bap.Std.Exp.t -> Bap.Std.Exp.t
val free_vars : Bap.Std.Exp.t -> Bap.Std.Var.Set.t
val eval : Bap.Std.Exp.t -> Bap.Std.Bil.value
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.Bil.exp
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Type_error.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val pp_adt : Bap.Std.Exp.t Regular.Std.printer
end
module Stmt :
sig
type t = Bap.Std.Bil.stmt
class state :
object
val in_jmp : bool
val in_loop : bool
val in_move : bool
val preds : Bap.Std.stmt list
val stmts_stack : Bap.Std.stmt list
val succs : Bap.Std.stmt list
end
class ['a] visitor :
object
val exps_stack : exp list
val in_jmp : bool
val in_loop : bool
val in_move : bool
val preds : stmt list
val stmts_stack : stmt list
val succs : stmt list
val under_condition : bool
method enter_binop : binop -> Exp.t -> Exp.t -> 'a -> 'a
method enter_cast : cast -> int -> Exp.t -> 'a -> 'a
method enter_concat : Exp.t -> Exp.t -> 'a -> 'a
method enter_cpuexn : int -> 'a -> 'a
method enter_exp : Exp.t -> 'a -> 'a
method enter_extract : hi:int -> lo:int -> Exp.t -> 'a -> 'a
method enter_if :
cond:Bap.Std.exp ->
yes:Bap.Std.Stmt.t list -> no:Bap.Std.Stmt.t list -> 'a -> 'a
method enter_int : word -> 'a -> 'a
method enter_ite :
cond:Exp.t -> yes:Exp.t -> no:Exp.t -> 'a -> 'a
method enter_jmp : Bap.Std.exp -> 'a -> 'a
method enter_let : var -> exp:Exp.t -> body:Exp.t -> 'a -> 'a
method enter_load :
mem:Exp.t -> addr:Exp.t -> endian -> size -> 'a -> 'a
method enter_move : Bap.Std.var -> Bap.Std.exp -> 'a -> 'a
method enter_special : string -> 'a -> 'a
method enter_stmt : Bap.Std.Stmt.t -> 'a -> 'a
method enter_store :
mem:Exp.t ->
addr:Exp.t -> exp:Exp.t -> endian -> size -> 'a -> 'a
method enter_unknown :
Trie.String.Suffix.key -> typ -> 'a -> 'a
method enter_unop : unop -> Exp.t -> 'a -> 'a
method enter_var : var -> 'a -> 'a
method enter_while :
cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> 'a -> 'a
method leave_binop : binop -> Exp.t -> Exp.t -> 'a -> 'a
method leave_cast : cast -> int -> Exp.t -> 'a -> 'a
method leave_concat : Exp.t -> Exp.t -> 'a -> 'a
method leave_cpuexn : int -> 'a -> 'a
method leave_exp : Exp.t -> 'a -> 'a
method leave_extract : hi:int -> lo:int -> Exp.t -> 'a -> 'a
method leave_if :
cond:Bap.Std.exp ->
yes:Bap.Std.Stmt.t list -> no:Bap.Std.Stmt.t list -> 'a -> 'a
method leave_int : word -> 'a -> 'a
method leave_ite :
cond:Exp.t -> yes:Exp.t -> no:Exp.t -> 'a -> 'a
method leave_jmp : Bap.Std.exp -> 'a -> 'a
method leave_let : var -> exp:Exp.t -> body:Exp.t -> 'a -> 'a
method leave_load :
mem:Exp.t -> addr:Exp.t -> endian -> size -> 'a -> 'a
method leave_move : Bap.Std.var -> Bap.Std.exp -> 'a -> 'a
method leave_special : string -> 'a -> 'a
method leave_stmt : Bap.Std.Stmt.t -> 'a -> 'a
method leave_store :
mem:Exp.t ->
addr:Exp.t -> exp:Exp.t -> endian -> size -> 'a -> 'a
method leave_unknown :
Trie.String.Suffix.key -> typ -> 'a -> 'a
method leave_unop : unop -> Exp.t -> 'a -> 'a
method leave_var : var -> 'a -> 'a
method leave_while :
cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> 'a -> 'a
method run : Bap.Std.Stmt.t list -> 'a -> 'a
method visit_binop : binop -> Exp.t -> Exp.t -> 'a -> 'a
method visit_cast : cast -> int -> Exp.t -> 'a -> 'a
method visit_concat : Exp.t -> Exp.t -> 'a -> 'a
method visit_cpuexn : int -> 'a -> 'a
method visit_exp : Exp.t -> 'a -> 'a
method visit_extract : hi:int -> lo:int -> Exp.t -> 'a -> 'a
method visit_if :
cond:Bap.Std.exp ->
yes:Bap.Std.Stmt.t list -> no:Bap.Std.Stmt.t list -> 'a -> 'a
method visit_int : word -> 'a -> 'a
method visit_ite :
cond:Exp.t -> yes:Exp.t -> no:Exp.t -> 'a -> 'a
method visit_jmp : Bap.Std.exp -> 'a -> 'a
method visit_let : var -> exp:Exp.t -> body:Exp.t -> 'a -> 'a
method visit_load :
mem:Exp.t -> addr:Exp.t -> endian -> size -> 'a -> 'a
method visit_move : Bap.Std.var -> Bap.Std.exp -> 'a -> 'a
method visit_special : string -> 'a -> 'a
method visit_stmt : Bap.Std.Stmt.t -> 'a -> 'a
method visit_store :
mem:Exp.t ->
addr:Exp.t -> exp:Exp.t -> endian -> size -> 'a -> 'a
method visit_unknown :
Trie.String.Suffix.key -> typ -> 'a -> 'a
method visit_unop : unop -> Exp.t -> 'a -> 'a
method visit_var : var -> 'a -> 'a
method visit_while :
cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> 'a -> 'a
end
class ['a] finder :
object
val exps_stack : exp list
val in_jmp : bool
val in_loop : bool
val in_move : bool
val preds : stmt list
val stmts_stack : stmt list
val succs : stmt list
val under_condition : bool
method enter_binop :
binop ->
Exp.t ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_cast :
cast ->
int ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_concat :
Exp.t ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_cpuexn :
int ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_exp :
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_extract :
hi:int ->
lo:int ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_if :
cond:exp ->
yes:t list ->
no:t list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_int :
word ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_ite :
cond:Exp.t ->
yes:Exp.t ->
no:Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_jmp :
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_let :
var ->
exp:Exp.t ->
body:Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_load :
mem:Exp.t ->
addr:Exp.t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_move :
var ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_special :
Trie.String.Suffix.key ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_stmt :
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_store :
mem:Exp.t ->
addr:Exp.t ->
exp:Exp.t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_unknown :
Trie.String.Suffix.key ->
typ ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_unop :
unop ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_var :
var ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_while :
cond:exp ->
t list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method find : Bap.Std.Stmt.t list -> 'a option
method leave_binop :
binop ->
Exp.t ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_cast :
cast ->
int ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_concat :
Exp.t ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_cpuexn :
int ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_exp :
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_extract :
hi:int ->
lo:int ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_if :
cond:exp ->
yes:t list ->
no:t list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_int :
word ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_ite :
cond:Exp.t ->
yes:Exp.t ->
no:Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_jmp :
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_let :
var ->
exp:Exp.t ->
body:Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_load :
mem:Exp.t ->
addr:Exp.t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_move :
var ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_special :
Trie.String.Suffix.key ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_stmt :
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_store :
mem:Exp.t ->
addr:Exp.t ->
exp:Exp.t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_unknown :
Trie.String.Suffix.key ->
typ ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_unop :
unop ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_var :
var ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_while :
cond:exp ->
t list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method run :
t list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_binop :
binop ->
Exp.t ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_cast :
cast ->
int ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_concat :
Exp.t ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_cpuexn :
int ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_exp :
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_extract :
hi:int ->
lo:int ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_if :
cond:exp ->
yes:t list ->
no:t list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_int :
word ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_ite :
cond:Exp.t ->
yes:Exp.t ->
no:Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_jmp :
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_let :
var ->
exp:Exp.t ->
body:Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_load :
mem:Exp.t ->
addr:Exp.t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_move :
var ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_special :
Trie.String.Suffix.key ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_stmt :
t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_store :
mem:Exp.t ->
addr:Exp.t ->
exp:Exp.t ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_unknown :
Trie.String.Suffix.key ->
typ ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_unop :
unop ->
Exp.t ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_var :
var ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_while :
cond:exp ->
t list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
end
class mapper :
object
val exps_stack : exp list
val in_jmp : bool
val in_loop : bool
val in_move : bool
val preds : stmt list
val stmts_stack : stmt list
val succs : stmt list
val under_condition : bool
method map_binop : binop -> Exp.t -> Exp.t -> Exp.t
method map_cast : cast -> int -> Exp.t -> Exp.t
method map_concat : Exp.t -> Exp.t -> Exp.t
method map_cpuexn : int -> Bap.Std.Stmt.t list
method map_exp : Exp.t -> Exp.t
method map_extract : hi:int -> lo:int -> Exp.t -> Exp.t
method map_if :
cond:Bap.Std.exp ->
yes:Bap.Std.Stmt.t list ->
no:Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
method map_int : word -> Exp.t
method map_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> Exp.t
method map_jmp : Bap.Std.exp -> Bap.Std.Stmt.t list
method map_let : var -> exp:Exp.t -> body:Exp.t -> Exp.t
method map_load :
mem:Exp.t -> addr:Exp.t -> endian -> size -> Exp.t
method map_move :
Bap.Std.var -> Bap.Std.exp -> Bap.Std.Stmt.t list
method map_special : string -> Bap.Std.Stmt.t list
method map_stmt : Bap.Std.Stmt.t -> Bap.Std.Stmt.t list
method map_store :
mem:Exp.t ->
addr:Exp.t -> exp:Exp.t -> endian -> size -> Exp.t
method map_sym : var -> var
method map_unknown : Trie.String.Suffix.key -> typ -> Exp.t
method map_unop : unop -> Exp.t -> Exp.t
method map_var : var -> Exp.t
method map_while :
cond:Bap.Std.exp ->
Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
method run : Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
end
class constant_folder : mapper
val fold :
'a #Bap.Std.Stmt.visitor -> init:'a -> Bap.Std.Stmt.t -> 'a
val iter : unit #Bap.Std.Stmt.visitor -> Bap.Std.Stmt.t -> unit
val map :
#Bap.Std.Stmt.mapper ->
Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
val find : 'a #Bap.Std.Stmt.finder -> Bap.Std.Stmt.t -> 'a option
val exists : unit #Bap.Std.Stmt.finder -> Bap.Std.Stmt.t -> bool
val is_referenced : Bap.Std.var -> Bap.Std.Stmt.t -> bool
val normalize :
?normalize_exp:bool -> Bap.Std.stmt list -> Bap.Std.stmt list
val simpl :
?ignore:Bap.Std.Eff.t list ->
Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
val fixpoint :
(Bap.Std.Stmt.t -> Bap.Std.Stmt.t) ->
Bap.Std.Stmt.t -> Bap.Std.Stmt.t
val free_vars : Bap.Std.Stmt.t -> Bap.Std.Var.Set.t
val eval :
Bap.Std.Stmt.t list -> (#Bap.Std.Bili.context as 'a) -> 'a
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.Bil.stmt
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Exp.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val pp_adt : Bap.Std.Stmt.t Regular.Std.printer
end
module Arch :
sig
type x86 = [ `x86 | `x86_64 ]
val bin_x86 : x86 Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_x86 : x86 Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_x86__ :
(int -> x86) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_x86 : x86 Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_x86 : x86 Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_x86 : x86 Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_x86 : x86 Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_x86 : Core_kernel.Std.Bin_prot.Shape.t
val compare_x86 : x86 -> x86 -> int
val all_of_x86 : x86 list
val x86_of_sexp : Sexplib.Sexp.t -> x86
val __x86_of_sexp__ : Sexplib.Sexp.t -> x86
val sexp_of_x86 : x86 -> Sexplib.Sexp.t
type arm = [ `armv4 | `armv5 | `armv6 | `armv7 ]
val bin_arm : arm Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_arm : arm Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_arm__ :
(int -> arm) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_arm : arm Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_arm : arm Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_arm : arm Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_arm : arm Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_arm : Core_kernel.Std.Bin_prot.Shape.t
val compare_arm : arm -> arm -> int
val all_of_arm : arm list
val arm_of_sexp : Sexplib.Sexp.t -> arm
val __arm_of_sexp__ : Sexplib.Sexp.t -> arm
val sexp_of_arm : arm -> Sexplib.Sexp.t
type armeb = [ `armv4eb | `armv5eb | `armv6eb | `armv7eb ]
val bin_armeb : armeb Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_armeb : armeb Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_armeb__ :
(int -> armeb) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_armeb :
armeb Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_armeb : armeb Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_armeb : armeb Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_armeb :
armeb Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_armeb : Core_kernel.Std.Bin_prot.Shape.t
val compare_armeb : armeb -> armeb -> int
val all_of_armeb : armeb list
val armeb_of_sexp : Sexplib.Sexp.t -> armeb
val __armeb_of_sexp__ : Sexplib.Sexp.t -> armeb
val sexp_of_armeb : armeb -> Sexplib.Sexp.t
type thumb = [ `thumbv4 | `thumbv5 | `thumbv6 | `thumbv7 ]
val bin_thumb : thumb Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_thumb : thumb Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_thumb__ :
(int -> thumb) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_thumb :
thumb Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_thumb : thumb Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_thumb : thumb Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_thumb :
thumb Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_thumb : Core_kernel.Std.Bin_prot.Shape.t
val compare_thumb : thumb -> thumb -> int
val all_of_thumb : thumb list
val thumb_of_sexp : Sexplib.Sexp.t -> thumb
val __thumb_of_sexp__ : Sexplib.Sexp.t -> thumb
val sexp_of_thumb : thumb -> Sexplib.Sexp.t
type thumbeb =
[ `thumbv4eb | `thumbv5eb | `thumbv6eb | `thumbv7eb ]
val bin_thumbeb : thumbeb Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_thumbeb : thumbeb Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_thumbeb__ :
(int -> thumbeb) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_thumbeb :
thumbeb Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_thumbeb : thumbeb Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_thumbeb :
thumbeb Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_thumbeb :
thumbeb Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_thumbeb : Core_kernel.Std.Bin_prot.Shape.t
val compare_thumbeb : thumbeb -> thumbeb -> int
val all_of_thumbeb : thumbeb list
val thumbeb_of_sexp : Sexplib.Sexp.t -> thumbeb
val __thumbeb_of_sexp__ : Sexplib.Sexp.t -> thumbeb
val sexp_of_thumbeb : thumbeb -> Sexplib.Sexp.t
type aarch64 = [ `aarch64 | `aarch64_be ]
val bin_aarch64 : aarch64 Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_aarch64 : aarch64 Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_aarch64__ :
(int -> aarch64) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_aarch64 :
aarch64 Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_aarch64 : aarch64 Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_aarch64 :
aarch64 Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_aarch64 :
aarch64 Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_aarch64 : Core_kernel.Std.Bin_prot.Shape.t
val compare_aarch64 : aarch64 -> aarch64 -> int
val all_of_aarch64 : aarch64 list
val aarch64_of_sexp : Sexplib.Sexp.t -> aarch64
val __aarch64_of_sexp__ : Sexplib.Sexp.t -> aarch64
val sexp_of_aarch64 : aarch64 -> Sexplib.Sexp.t
type ppc = [ `ppc | `ppc64 | `ppc64le ]
val bin_ppc : ppc Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_ppc : ppc Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_ppc__ :
(int -> ppc) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_ppc : ppc Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_ppc : ppc Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_ppc : ppc Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_ppc : ppc Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_ppc : Core_kernel.Std.Bin_prot.Shape.t
val compare_ppc : ppc -> ppc -> int
val all_of_ppc : ppc list
val ppc_of_sexp : Sexplib.Sexp.t -> ppc
val __ppc_of_sexp__ : Sexplib.Sexp.t -> ppc
val sexp_of_ppc : ppc -> Sexplib.Sexp.t
type mips = [ `mips | `mips64 | `mips64el | `mipsel ]
val bin_mips : mips Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_mips : mips Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_mips__ :
(int -> mips) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_mips :
mips Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_mips : mips Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_mips : mips Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_mips :
mips Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_mips : Core_kernel.Std.Bin_prot.Shape.t
val compare_mips : mips -> mips -> int
val all_of_mips : mips list
val mips_of_sexp : Sexplib.Sexp.t -> mips
val __mips_of_sexp__ : Sexplib.Sexp.t -> mips
val sexp_of_mips : mips -> Sexplib.Sexp.t
type sparc = [ `sparc | `sparcv9 ]
val bin_sparc : sparc Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_sparc : sparc Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_sparc__ :
(int -> sparc) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_sparc :
sparc Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_sparc : sparc Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_sparc : sparc Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_sparc :
sparc Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_sparc : Core_kernel.Std.Bin_prot.Shape.t
val compare_sparc : sparc -> sparc -> int
val all_of_sparc : sparc list
val sparc_of_sexp : Sexplib.Sexp.t -> sparc
val __sparc_of_sexp__ : Sexplib.Sexp.t -> sparc
val sexp_of_sparc : sparc -> Sexplib.Sexp.t
type nvptx = [ `nvptx | `nvptx64 ]
val bin_nvptx : nvptx Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_nvptx : nvptx Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_nvptx__ :
(int -> nvptx) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_nvptx :
nvptx Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_nvptx : nvptx Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_nvptx : nvptx Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_nvptx :
nvptx Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_nvptx : Core_kernel.Std.Bin_prot.Shape.t
val compare_nvptx : nvptx -> nvptx -> int
val all_of_nvptx : nvptx list
val nvptx_of_sexp : Sexplib.Sexp.t -> nvptx
val __nvptx_of_sexp__ : Sexplib.Sexp.t -> nvptx
val sexp_of_nvptx : nvptx -> Sexplib.Sexp.t
type hexagon = [ `hexagon ]
val bin_hexagon : hexagon Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_hexagon : hexagon Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_hexagon__ :
(int -> hexagon) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_hexagon :
hexagon Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_hexagon : hexagon Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_hexagon :
hexagon Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_hexagon :
hexagon Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_hexagon : Core_kernel.Std.Bin_prot.Shape.t
val compare_hexagon : hexagon -> hexagon -> int
val all_of_hexagon : hexagon list
val hexagon_of_sexp : Sexplib.Sexp.t -> hexagon
val __hexagon_of_sexp__ : Sexplib.Sexp.t -> hexagon
val sexp_of_hexagon : hexagon -> Sexplib.Sexp.t
type r600 = [ `r600 ]
val bin_r600 : r600 Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_r600 : r600 Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_r600__ :
(int -> r600) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_r600 :
r600 Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_r600 : r600 Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_r600 : r600 Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_r600 :
r600 Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_r600 : Core_kernel.Std.Bin_prot.Shape.t
val compare_r600 : r600 -> r600 -> int
val all_of_r600 : r600 list
val r600_of_sexp : Sexplib.Sexp.t -> r600
val __r600_of_sexp__ : Sexplib.Sexp.t -> r600
val sexp_of_r600 : r600 -> Sexplib.Sexp.t
type systemz = [ `systemz ]
val bin_systemz : systemz Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_systemz : systemz Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_systemz__ :
(int -> systemz) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_systemz :
systemz Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_systemz : systemz Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_systemz :
systemz Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_systemz :
systemz Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_systemz : Core_kernel.Std.Bin_prot.Shape.t
val compare_systemz : systemz -> systemz -> int
val all_of_systemz : systemz list
val systemz_of_sexp : Sexplib.Sexp.t -> systemz
val __systemz_of_sexp__ : Sexplib.Sexp.t -> systemz
val sexp_of_systemz : systemz -> Sexplib.Sexp.t
type xcore = [ `xcore ]
val bin_xcore : xcore Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_xcore : xcore Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_xcore__ :
(int -> xcore) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_xcore :
xcore Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_xcore : xcore Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_xcore : xcore Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_xcore :
xcore Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_xcore : Core_kernel.Std.Bin_prot.Shape.t
val compare_xcore : xcore -> xcore -> int
val all_of_xcore : xcore list
val xcore_of_sexp : Sexplib.Sexp.t -> xcore
val __xcore_of_sexp__ : Sexplib.Sexp.t -> xcore
val sexp_of_xcore : xcore -> Sexplib.Sexp.t
type t =
[ `aarch64
| `aarch64_be
| `armv4
| `armv4eb
| `armv5
| `armv5eb
| `armv6
| `armv6eb
| `armv7
| `armv7eb
| `hexagon
| `mips
| `mips64
| `mips64el
| `mipsel
| `nvptx
| `nvptx64
| `ppc
| `ppc64
| `ppc64le
| `r600
| `sparc
| `sparcv9
| `systemz
| `thumbv4
| `thumbv4eb
| `thumbv5
| `thumbv5eb
| `thumbv6
| `thumbv6eb
| `thumbv7
| `thumbv7eb
| `x86
| `x86_64
| `xcore ]
val all : t list
val __t_of_sexp__ : Sexplib.Sexp.t -> t
val of_string : string -> Bap.Std.Arch.t option
val addr_size : Bap.Std.Arch.t -> Bap.Std.addr_size
val endian : Bap.Std.Arch.t -> Bap.Std.endian
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Stmt.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
type arch = Bap.Std.Arch.t
val bin_arch : arch Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_arch : arch Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_arch__ :
(int -> arch) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_arch : arch Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_arch : arch Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_arch : arch Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_arch : arch Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_arch : Core_kernel.Std.Bin_prot.Shape.t
val compare_arch : arch -> arch -> int
val arch_of_sexp : Sexplib.Sexp.t -> arch
val sexp_of_arch : arch -> Sexplib.Sexp.t
module Value :
sig
type t = Bap.Std.value
type 'a tag
module type S =
sig
type t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val pp : Format.formatter -> Bap.Std.Value.S.t -> unit
end
type void
type literal =
(Bap.Std.Value.void, Bap.Std.Value.void, Bap.Std.Value.void)
Core_kernel.Std.format
type typeid
val bin_typeid : typeid Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_typeid : typeid Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_typeid__ :
(int -> typeid) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_typeid :
typeid Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_typeid : typeid Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_typeid : typeid Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_typeid :
typeid Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_typeid : Core_kernel.Std.Bin_prot.Shape.t
val compare_typeid : typeid -> typeid -> int
val typeid_of_sexp : Sexplib.Sexp.t -> typeid
val sexp_of_typeid : typeid -> Sexplib.Sexp.t
val create : 'a Bap.Std.Value.tag -> 'a -> Bap.Std.Value.t
val is : 'a Bap.Std.Value.tag -> Bap.Std.Value.t -> bool
val get : 'a Bap.Std.Value.tag -> Bap.Std.Value.t -> 'a option
val get_exn : 'a Bap.Std.Value.tag -> Bap.Std.Value.t -> 'a
val tagname : Bap.Std.Value.t -> string
val typeid : Bap.Std.Value.t -> Bap.Std.Value.typeid
module Tag :
sig
type 'a t = 'a Bap.Std.Value.tag
val register :
name:Bap.Std.Value.literal ->
uuid:Bap.Std.Value.literal ->
(module Bap.Std.Value.S with type t = 'a) ->
'a Bap.Std.Value.tag
val name : 'a Bap.Std.Value.Tag.t -> string
val same :
'a Bap.Std.Value.Tag.t -> 'b Bap.Std.Value.Tag.t -> bool
val same_witness :
'a Bap.Std.Value.Tag.t ->
'b Bap.Std.Value.Tag.t ->
('a, 'b) Core_kernel.Std.Type_equal.t option
val same_witness_exn :
'a Bap.Std.Value.Tag.t ->
'b Bap.Std.Value.Tag.t ->
('a, 'b) Core_kernel.Std.Type_equal.t
val typeid : 'a Bap.Std.Value.Tag.t -> Bap.Std.Value.typeid
end
module Match :
sig
type 'a t
val switch : Bap.Std.value -> 's Bap.Std.Value.Match.t -> 's
val select : 's Bap.Std.Value.Match.t -> Bap.Std.value -> 's
val case :
'a Bap.Std.Value.tag ->
('a -> 's) ->
's Bap.Std.Value.Match.t -> 's Bap.Std.Value.Match.t
val default : (unit -> 's) -> 's Bap.Std.Value.Match.t
end
module Typeid :
sig
type t = typeid
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val of_string : Trie.String.Suffix.key -> t
val to_string : t -> Trie.String.Suffix.key
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = typeid
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(typeid, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : typeid -> 'a -> 'a t
val of_alist :
(typeid * 'a) list ->
[ `Duplicate_key of typeid | `Ok of 'a t ]
val of_alist_or_error :
(typeid * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (typeid * 'a) list -> 'a t
val of_alist_multi : (typeid * 'a) list -> 'a list t
val of_alist_fold :
(typeid * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(typeid * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(typeid * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(typeid * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> typeid * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:typeid -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of typeid | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(typeid, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
typeid Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:typeid -> data:'a -> 'a t
val add_multi :
'a list t -> key:typeid -> data:'a -> 'a list t
val remove_multi : 'a list t -> typeid -> 'a list t
val change :
'a t -> typeid -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> typeid -> f:('a option -> 'a) -> 'a t
val find : 'a t -> typeid -> 'a option
val find_exn : 'a t -> typeid -> 'a
val remove : 'a t -> typeid -> 'a t
val mem : 'a t -> typeid -> bool
val iter_keys : 'a t -> f:(typeid -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:typeid -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:typeid ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:typeid -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:typeid -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:typeid -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:typeid ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(typeid -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:typeid -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:typeid -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:typeid ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:typeid -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> typeid list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (typeid * 'a) list
val validate :
name:(typeid -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:typeid ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(typeid, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (typeid * 'a) option
val min_elt_exn : 'a t -> typeid * 'a
val max_elt : 'a t -> (typeid * 'a) option
val max_elt_exn : 'a t -> typeid * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:typeid -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:typeid -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:typeid -> data:'a -> bool) -> int
val split :
'a t -> typeid -> 'a t * (typeid * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:typeid Base__.Maybe_bound.t ->
upper_bound:typeid Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:typeid ->
max:typeid ->
init:'b ->
f:(key:typeid -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:typeid -> max:typeid -> (typeid * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> typeid -> (typeid * 'a) option
val nth : 'a t -> int -> (typeid * 'a) option
val nth_exn : 'a t -> int -> typeid * 'a
val rank : 'a t -> typeid -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:typeid ->
?keys_less_or_equal_to:typeid ->
'a t -> (typeid * 'a) Base__.Sequence.t
val obs :
typeid Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
typeid Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> typeid
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(typeid, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : typeid -> 'a -> 'a t
val of_alist :
(typeid * 'a) list ->
[ `Duplicate_key of typeid | `Ok of 'a t ]
val of_alist_or_error :
(typeid * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (typeid * 'a) list -> 'a t
val of_alist_multi : (typeid * 'a) list -> 'a list t
val of_alist_fold :
(typeid * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(typeid * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(typeid * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (typeid * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> typeid * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:typeid -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of typeid | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(typeid, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
typeid Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:typeid -> data:'a -> 'a t
val add_multi :
'a list t -> key:typeid -> data:'a -> 'a list t
val remove_multi : 'a list t -> typeid -> 'a list t
val change :
'a t -> typeid -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> typeid -> f:('a option -> 'a) -> 'a t
val find : 'a t -> typeid -> 'a option
val find_exn : 'a t -> typeid -> 'a
val remove : 'a t -> typeid -> 'a t
val mem : 'a t -> typeid -> bool
val iter_keys : 'a t -> f:(typeid -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:typeid -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:typeid ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:typeid -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:typeid -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:typeid -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:typeid ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(typeid -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:typeid -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:typeid -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:typeid -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:typeid -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> typeid list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (typeid * 'a) list
val validate :
name:(typeid -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:typeid ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(typeid, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (typeid * 'a) option
val min_elt_exn : 'a t -> typeid * 'a
val max_elt : 'a t -> (typeid * 'a) option
val max_elt_exn : 'a t -> typeid * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:typeid -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:typeid -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:typeid -> data:'a -> bool) -> int
val split :
'a t -> typeid -> 'a t * (typeid * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:typeid Base__.Maybe_bound.t ->
upper_bound:typeid Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:typeid ->
max:typeid ->
init:'b -> f:(key:typeid -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:typeid -> max:typeid -> (typeid * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> typeid -> (typeid * 'a) option
val nth : 'a t -> int -> (typeid * 'a) option
val nth_exn : 'a t -> int -> typeid * 'a
val rank : 'a t -> typeid -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:typeid ->
?keys_less_or_equal_to:typeid ->
'a t -> (typeid * 'a) Base__.Sequence.t
val obs :
typeid Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
typeid Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> typeid end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : typeid Bin_prot.Type_class.t
val bin_read_t : typeid Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> typeid)
Bin_prot.Read.reader
val bin_reader_t :
typeid Bin_prot.Type_class.reader
val bin_size_t : typeid Bin_prot.Size.sizer
val bin_write_t : typeid Bin_prot.Write.writer
val bin_writer_t :
typeid Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
typeid -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = typeid
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(typeid, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(typeid -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> typeid -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> typeid -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(typeid -> bool) -> bool
val for_all : t -> f:(typeid -> bool) -> bool
val count : t -> f:(typeid -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(typeid -> 'sum) -> 'sum
val find : t -> f:(typeid -> bool) -> typeid option
val find_map :
t -> f:(typeid -> 'a option) -> 'a option
val to_list : t -> typeid list
val to_array : t -> typeid array
val invariants : t -> bool
val mem : t -> typeid -> bool
val add : t -> typeid -> t
val remove : t -> typeid -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(typeid, typeid) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
typeid ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(typeid -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of typeid * typeid
| `Left of typeid
| `Right of typeid ] -> unit) ->
unit
val filter : t -> f:(typeid -> bool) -> t
val partition_tf : t -> f:(typeid -> bool) -> t * t
val elements : t -> typeid list
val min_elt : t -> typeid option
val min_elt_exn : t -> typeid
val max_elt : t -> typeid option
val max_elt_exn : t -> typeid
val choose : t -> typeid option
val choose_exn : t -> typeid
val split : t -> typeid -> t * typeid option * t
val group_by :
t -> equiv:(typeid -> typeid -> bool) -> t list
val find_exn : t -> f:(typeid -> bool) -> typeid
val find_index : t -> int -> typeid option
val nth : t -> int -> typeid option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:typeid ->
?less_or_equal_to:typeid ->
t -> typeid Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:typeid ->
?less_or_equal_to:typeid ->
t ->
t ->
(typeid, typeid)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(typeid -> 'data) ->
(typeid, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
typeid Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
typeid Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : typeid -> t
val union_list : t list -> t
val of_list : typeid list -> t
val of_array : typeid array -> t
val of_sorted_array :
typeid array -> t Base__.Or_error.t
val of_sorted_array_unchecked : typeid array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> typeid) -> t
val stable_dedup_list : typeid list -> typeid list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> typeid) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> typeid option) -> t
val of_tree : t -> t
val of_hash_set : typeid Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(typeid, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(typeid, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
typeid Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> typeid
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (typeid, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(typeid -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> typeid -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> typeid -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(typeid -> bool) -> bool
val for_all : t -> f:(typeid -> bool) -> bool
val count : t -> f:(typeid -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(typeid -> 'sum) -> 'sum
val find : t -> f:(typeid -> bool) -> typeid option
val find_map : t -> f:(typeid -> 'a option) -> 'a option
val to_list : t -> typeid list
val to_array : t -> typeid array
val invariants : t -> bool
val mem : t -> typeid -> bool
val add : t -> typeid -> t
val remove : t -> typeid -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (typeid, typeid) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
typeid ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(typeid -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of typeid * typeid
| `Left of typeid
| `Right of typeid ] -> unit) ->
unit
val filter : t -> f:(typeid -> bool) -> t
val partition_tf : t -> f:(typeid -> bool) -> t * t
val elements : t -> typeid list
val min_elt : t -> typeid option
val min_elt_exn : t -> typeid
val max_elt : t -> typeid option
val max_elt_exn : t -> typeid
val choose : t -> typeid option
val choose_exn : t -> typeid
val split : t -> typeid -> t * typeid option * t
val group_by :
t -> equiv:(typeid -> typeid -> bool) -> t list
val find_exn : t -> f:(typeid -> bool) -> typeid
val find_index : t -> int -> typeid option
val nth : t -> int -> typeid option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:typeid ->
?less_or_equal_to:typeid -> t -> typeid Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:typeid ->
?less_or_equal_to:typeid ->
t ->
t ->
(typeid, typeid)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(typeid -> 'data) ->
(typeid, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
typeid Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
typeid Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : typeid -> t
val union_list : t list -> t
val of_list : typeid list -> t
val of_array : typeid array -> t
val of_sorted_array : typeid array -> t Base__.Or_error.t
val of_sorted_array_unchecked : typeid array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> typeid) -> t
val stable_dedup_list : typeid list -> typeid list
val map : ('a, 'b) Base.Set.t -> f:('a -> typeid) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> typeid option) -> t
val of_tree : Tree.t -> t
val of_hash_set : typeid Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(typeid, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(typeid, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
typeid Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> typeid end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : typeid Bin_prot.Type_class.t
val bin_read_t : typeid Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> typeid)
Bin_prot.Read.reader
val bin_reader_t :
typeid Bin_prot.Type_class.reader
val bin_size_t : typeid Bin_prot.Size.sizer
val bin_write_t : typeid Bin_prot.Write.writer
val bin_writer_t :
typeid Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
typeid -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel__.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel__.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = typeid
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> typeid -> Core_kernel__.Import.bool
val lookup :
'a t -> typeid -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> typeid -> 'a
val enqueue :
'a t -> typeid -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> typeid -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> typeid -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> typeid -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (typeid * 'a) Core_kernel__.Import.option
val keys : 'a t -> typeid Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (typeid * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> typeid * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> typeid -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> typeid -> Core_kernel__.Import.unit
val replace :
'a t -> typeid -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> typeid -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:typeid -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:typeid -> data:'a -> 'b) -> 'b
end
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.value
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Arch.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
type 'a tag = 'a Bap.Std.Value.tag
module Dict :
sig
type t = Bap.Std.dict
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val empty : Bap.Std.Dict.t
val is_empty : Bap.Std.Dict.t -> bool
val set : Bap.Std.Dict.t -> 'a Bap.Std.tag -> 'a -> Bap.Std.Dict.t
val mem : Bap.Std.Dict.t -> 'a Bap.Std.tag -> bool
val find : Bap.Std.Dict.t -> 'a Bap.Std.tag -> 'a option
val add :
Bap.Std.Dict.t ->
'a Bap.Std.tag -> 'a -> [ `Duplicate | `Ok of Bap.Std.Dict.t ]
val change :
Bap.Std.Dict.t ->
'a Bap.Std.tag -> ('a option -> 'a option) -> Bap.Std.Dict.t
val remove : Bap.Std.Dict.t -> 'a Bap.Std.tag -> Bap.Std.Dict.t
val to_sequence :
Bap.Std.Dict.t ->
(Bap.Std.Value.typeid * Bap.Std.value) Bap.Std.seq
val data : Bap.Std.Dict.t -> Bap.Std.value Bap.Std.seq
val filter :
Bap.Std.Dict.t -> f:(Bap.Std.value -> bool) -> Bap.Std.Dict.t
end
type 'a vector
module Vector :
sig
type 'a t = 'a Bap.Std.vector
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val create : ?capacity:int -> 'a -> 'a Bap.Std.Vector.t
val append : 'a Bap.Std.Vector.t -> 'a -> unit
val nth : 'a Bap.Std.Vector.t -> int -> 'a option
val get : 'a Bap.Std.Vector.t -> int -> 'a
val set : 'a Bap.Std.Vector.t -> int -> 'a -> unit
val map_to_array : 'a Bap.Std.Vector.t -> f:('a -> 'b) -> 'b array
val findi :
'a Bap.Std.Vector.t -> f:(int -> 'a -> bool) -> (int * 'a) option
val iteri : 'a Bap.Std.Vector.t -> f:(int -> 'a -> unit) -> unit
val foldi :
'a Bap.Std.Vector.t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
val index :
?equal:('a -> 'a -> bool) ->
'a Bap.Std.Vector.t -> 'a -> int option
val index_exn :
?equal:('a -> 'a -> bool) -> 'a Bap.Std.Vector.t -> 'a -> int
val index_with :
?equal:('a -> 'a -> bool) ->
default:int -> 'a Bap.Std.Vector.t -> 'a -> int
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a -> ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop) Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val pp :
'a Regular.Std.printer -> 'a Bap.Std.Vector.t Regular.Std.printer
end
type 'a term
val bin_term :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a term Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_term :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a term Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_term__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a term) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_term :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a term Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_term :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a term Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_term :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a term Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_term :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a term Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_term :
Core_kernel.Std.Bin_prot.Shape.t -> Core_kernel.Std.Bin_prot.Shape.t
val compare_term : ('a -> 'a -> int) -> 'a term -> 'a term -> int
val term_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a term
val sexp_of_term : ('a -> Sexplib.Sexp.t) -> 'a term -> Sexplib.Sexp.t
type program
val bin_program : program Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_program : program Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_program__ :
(int -> program) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_program :
program Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_program : program Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_program : program Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_program :
program Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_program : Core_kernel.Std.Bin_prot.Shape.t
val compare_program : program -> program -> int
val program_of_sexp : Sexplib.Sexp.t -> program
val sexp_of_program : program -> Sexplib.Sexp.t
type sub
val bin_sub : sub Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_sub : sub Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_sub__ :
(int -> sub) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_sub : sub Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_sub : sub Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_sub : sub Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_sub : sub Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_sub : Core_kernel.Std.Bin_prot.Shape.t
val compare_sub : sub -> sub -> int
val sub_of_sexp : Sexplib.Sexp.t -> sub
val sexp_of_sub : sub -> Sexplib.Sexp.t
type arg
val bin_arg : arg Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_arg : arg Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_arg__ :
(int -> arg) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_arg : arg Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_arg : arg Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_arg : arg Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_arg : arg Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_arg : Core_kernel.Std.Bin_prot.Shape.t
val compare_arg : arg -> arg -> int
val arg_of_sexp : Sexplib.Sexp.t -> arg
val sexp_of_arg : arg -> Sexplib.Sexp.t
type blk
val bin_blk : blk Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_blk : blk Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_blk__ :
(int -> blk) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_blk : blk Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_blk : blk Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_blk : blk Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_blk : blk Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_blk : Core_kernel.Std.Bin_prot.Shape.t
val compare_blk : blk -> blk -> int
val blk_of_sexp : Sexplib.Sexp.t -> blk
val sexp_of_blk : blk -> Sexplib.Sexp.t
type phi
val bin_phi : phi Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_phi : phi Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_phi__ :
(int -> phi) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_phi : phi Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_phi : phi Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_phi : phi Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_phi : phi Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_phi : Core_kernel.Std.Bin_prot.Shape.t
val compare_phi : phi -> phi -> int
val phi_of_sexp : Sexplib.Sexp.t -> phi
val sexp_of_phi : phi -> Sexplib.Sexp.t
type def
val bin_def : def Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_def : def Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_def__ :
(int -> def) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_def : def Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_def : def Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_def : def Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_def : def Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_def : Core_kernel.Std.Bin_prot.Shape.t
val compare_def : def -> def -> int
val def_of_sexp : Sexplib.Sexp.t -> def
val sexp_of_def : def -> Sexplib.Sexp.t
type jmp
val bin_jmp : jmp Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_jmp : jmp Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_jmp__ :
(int -> jmp) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_jmp : jmp Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_jmp : jmp Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_jmp : jmp Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_jmp : jmp Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_jmp : Core_kernel.Std.Bin_prot.Shape.t
val compare_jmp : jmp -> jmp -> int
val jmp_of_sexp : Sexplib.Sexp.t -> jmp
val sexp_of_jmp : jmp -> Sexplib.Sexp.t
type nil
val bin_nil : nil Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_nil : nil Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_nil__ :
(int -> nil) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_nil : nil Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_nil : nil Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_nil : nil Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_nil : nil Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_nil : Core_kernel.Std.Bin_prot.Shape.t
val compare_nil : nil -> nil -> int
val nil_of_sexp : Sexplib.Sexp.t -> nil
val sexp_of_nil : nil -> Sexplib.Sexp.t
type tid
val bin_tid : tid Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_tid : tid Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_tid__ :
(int -> tid) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_tid : tid Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_tid : tid Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_tid : tid Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_tid : tid Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_tid : Core_kernel.Std.Bin_prot.Shape.t
val compare_tid : tid -> tid -> int
val tid_of_sexp : Sexplib.Sexp.t -> tid
val sexp_of_tid : tid -> Sexplib.Sexp.t
type call
val bin_call : call Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_call : call Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_call__ :
(int -> call) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_call : call Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_call : call Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_call : call Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_call : call Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_call : Core_kernel.Std.Bin_prot.Shape.t
val compare_call : call -> call -> int
val call_of_sexp : Sexplib.Sexp.t -> call
val sexp_of_call : call -> Sexplib.Sexp.t
type label = Direct of Bap.Std.tid | Indirect of Bap.Std.exp
val bin_label : label Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_label : label Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_label__ :
(int -> label) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_label : label Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_label : label Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_label : label Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_label : label Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_label : Core_kernel.Std.Bin_prot.Shape.t
val compare_label : label -> label -> int
val label_of_sexp : Sexplib.Sexp.t -> label
val sexp_of_label : label -> Sexplib.Sexp.t
type jmp_kind =
Call of Bap.Std.call
| Goto of Bap.Std.label
| Ret of Bap.Std.label
| Int of int * Bap.Std.tid
val bin_jmp_kind : jmp_kind Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_jmp_kind : jmp_kind Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_jmp_kind__ :
(int -> jmp_kind) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_jmp_kind :
jmp_kind Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_jmp_kind : jmp_kind Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_jmp_kind : jmp_kind Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_jmp_kind :
jmp_kind Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_jmp_kind : Core_kernel.Std.Bin_prot.Shape.t
val compare_jmp_kind : jmp_kind -> jmp_kind -> int
val jmp_kind_of_sexp : Sexplib.Sexp.t -> jmp_kind
val sexp_of_jmp_kind : jmp_kind -> Sexplib.Sexp.t
type intent = In | Out | Both
val bin_intent : intent Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_intent : intent Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_intent__ :
(int -> intent) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_intent :
intent Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_intent : intent Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_intent : intent Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_intent :
intent Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_intent : Core_kernel.Std.Bin_prot.Shape.t
val compare_intent : intent -> intent -> int
val intent_of_sexp : Sexplib.Sexp.t -> intent
val sexp_of_intent : intent -> Sexplib.Sexp.t
type ('a, 'b) cls
val program_t : (Bap.Std.nil, Bap.Std.program) Bap.Std.cls
val sub_t : (Bap.Std.program, Bap.Std.sub) Bap.Std.cls
val arg_t : (Bap.Std.sub, Bap.Std.arg) Bap.Std.cls
val blk_t : (Bap.Std.sub, Bap.Std.blk) Bap.Std.cls
val phi_t : (Bap.Std.blk, Bap.Std.phi) Bap.Std.cls
val def_t : (Bap.Std.blk, Bap.Std.def) Bap.Std.cls
val jmp_t : (Bap.Std.blk, Bap.Std.jmp) Bap.Std.cls
module Biri :
sig
class context :
?main:Bap.Std.sub Bap.Std.term ->
Bap.Std.program Bap.Std.term ->
object ('a)
method bindings :
(Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
method create_storage :
Bap.Std.Bil.storage -> 'a * Bap.Std.Bil.result
method create_undefined : 'a * Bap.Std.Bil.result
method create_word : Bap.Std.word -> 'a * Bap.Std.Bil.result
method enter_term : Bap.Std.tid -> 'a
method lookup : Bap.Std.var -> Bap.Std.Bil.result option
method main : Bap.Std.sub Bap.Std.term option
method next : Bap.Std.tid option
method program : Bap.Std.program Bap.Std.term
method set_next : Bap.Std.tid option -> 'a
method trace : Bap.Std.tid list
method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
end
module type S =
sig
type ('a, 'e) state
type 'a u = (unit, 'a) Bap.Std.Biri.S.state
type 'a r = (Bap.Std.Bil.result, 'a) Bap.Std.Biri.S.state
module Expi :
sig
type ('a, 'e) state = ('a, 'e) state
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop :
binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast :
cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract :
int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Expi.context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] t :
object
constraint 'a = #Bap.Std.Biri.context
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method enter_term :
('p, 't) Bap.Std.cls ->
't Bap.Std.term -> 'a Bap.Std.Biri.S.u
method eval :
('p, 't) Bap.Std.cls ->
't Bap.Std.term -> 'a Bap.Std.Biri.S.u
method eval_arg :
Bap.Std.arg Bap.Std.term -> 'a Bap.Std.Biri.S.u
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_blk :
Bap.Std.blk Bap.Std.term -> 'a Bap.Std.Biri.S.u
method eval_call : Bap.Std.call -> 'a Bap.Std.Biri.S.u
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_def :
Bap.Std.def Bap.Std.term -> 'a Bap.Std.Biri.S.u
method eval_direct : Bap.Std.tid -> 'a Bap.Std.Biri.S.u
method eval_exn : int -> Bap.Std.tid -> 'a Bap.Std.Biri.S.u
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_goto : Bap.Std.label -> 'a Bap.Std.Biri.S.u
method eval_indirect : Bap.Std.exp -> 'a Bap.Std.Biri.S.u
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_jmp :
Bap.Std.jmp Bap.Std.term -> 'a Bap.Std.Biri.S.u
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_phi :
Bap.Std.phi Bap.Std.term -> 'a Bap.Std.Biri.S.u
method eval_ret : Bap.Std.label -> 'a Bap.Std.Biri.S.u
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_sub :
Bap.Std.sub Bap.Std.term -> 'a Bap.Std.Biri.S.u
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method leave_term :
('p, 't) Bap.Std.cls ->
't Bap.Std.term -> 'a Bap.Std.Biri.S.u
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
end
module Make :
functor (M : Monads.Std.Monad.State.S2) ->
sig
type ('a, 'e) state = ('a, 'e) M.t
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module Expi :
sig
type ('a, 'e) state = ('a, 'e) M.t
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop :
binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast :
cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract :
int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let :
var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update :
var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Expi.context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat :
exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp ->
yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key ->
typ -> (Bil.result, 'a) M.t
method eval_unop :
unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] t :
object
constraint 'a = #context
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method enter_term : ('p, 't) cls -> 't term -> 'a u
method eval : ('p, 't) cls -> 't term -> 'a u
method eval_arg : arg term -> 'a u
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_blk : blk term -> 'a u
method eval_call : call -> 'a u
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_def : def term -> 'a u
method eval_direct : tid -> 'a u
method eval_exn : int -> tid -> 'a u
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_goto : label -> 'a u
method eval_indirect : exp -> 'a u
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_jmp : jmp term -> 'a u
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_phi : phi term -> 'a u
method eval_ret : label -> 'a u
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_sub : sub term -> 'a u
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method leave_term : ('p, 't) cls -> 't term -> 'a u
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
end
type ('a, 'e) state = ('a, 'e) Bili.state
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module Expi :
sig
type ('a, 'e) state = ('a, 'e) Bili.state
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract : int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Expi.context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] t :
object
constraint 'a = #context
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method enter_term : ('p, 't) cls -> 't term -> 'a u
method eval : ('p, 't) cls -> 't term -> 'a u
method eval_arg : arg term -> 'a u
method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_blk : blk term -> 'a u
method eval_call : call -> 'a u
method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_def : def term -> 'a u
method eval_direct : tid -> 'a u
method eval_exn : int -> tid -> 'a u
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
method eval_goto : label -> 'a u
method eval_indirect : exp -> 'a u
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_jmp : jmp term -> 'a u
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_phi : phi term -> 'a u
method eval_ret : label -> 'a u
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_sub : sub term -> 'a u
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method leave_term : ('p, 't) cls -> 't term -> 'a u
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
end
class ['a] biri :
object
constraint 'a = #Bap.Std.Biri.context
method division_by_zero : unit -> 'a Biri.Expi.r
method empty : Bil.storage
method enter_term : ('p, 't) cls -> 't term -> 'a Biri.u
method eval : ('p, 't) cls -> 't term -> 'a Biri.u
method eval_arg : arg term -> 'a Biri.u
method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_blk : blk term -> 'a Biri.u
method eval_call : call -> 'a Biri.u
method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_def : def term -> 'a Biri.u
method eval_direct : tid -> 'a Biri.u
method eval_exn : int -> tid -> 'a Biri.u
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
method eval_goto : label -> 'a Biri.u
method eval_indirect : exp -> 'a Biri.u
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_jmp : jmp term -> 'a Biri.u
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_phi : phi term -> 'a Biri.u
method eval_ret : label -> 'a Biri.u
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_sub : sub term -> 'a Biri.u
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method leave_term : ('p, 't) cls -> 't term -> 'a Biri.u
method load : Bil.storage -> addr -> 'a Biri.Expi.r
method lookup : var -> 'a Biri.Expi.r
method store : Bil.storage -> addr -> word -> 'a Biri.Expi.r
method type_error : type_error -> 'a Biri.Expi.r
method undefined_addr : addr -> 'a Biri.Expi.r
method undefined_var : var -> 'a Biri.Expi.r
method update : var -> Bil.result -> 'a Biri.Expi.u
end
type color =
[ `black
| `blue
| `cyan
| `gray
| `green
| `magenta
| `red
| `white
| `yellow ]
val bin_color : color Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_color : color Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_color__ :
(int -> color) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_color : color Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_color : color Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_color : color Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_color : color Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_color : Core_kernel.Std.Bin_prot.Shape.t
val compare_color : color -> color -> int
val color_of_sexp : Sexplib.Sexp.t -> color
val __color_of_sexp__ : Sexplib.Sexp.t -> color
val sexp_of_color : color -> Sexplib.Sexp.t
val color : Bap.Std.color Bap.Std.tag
val foreground : Bap.Std.color Bap.Std.tag
val background : Bap.Std.color Bap.Std.tag
val comment : string Bap.Std.tag
val python : string Bap.Std.tag
val shell : string Bap.Std.tag
val mark : unit Bap.Std.tag
val weight : float Bap.Std.tag
val address : Bap.Std.addr Bap.Std.tag
val filename : string Bap.Std.tag
type image
type mem
val sexp_of_mem : mem -> Sexplib.Sexp.t
type 'a table
val sexp_of_table :
('a -> Sexplib.Sexp.t) -> 'a table -> Sexplib.Sexp.t
type 'a memmap
val sexp_of_memmap :
('a -> Sexplib.Sexp.t) -> 'a memmap -> Sexplib.Sexp.t
module type Memory_iterators =
sig
type t
type 'a m
val fold :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
init:'b ->
f:(Bap.Std.word -> 'b -> 'b Bap.Std.Memory_iterators.m) ->
'b Bap.Std.Memory_iterators.m
val iter :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.word -> unit Bap.Std.Memory_iterators.m) ->
unit Bap.Std.Memory_iterators.m
val foldi :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
init:'b ->
f:(Bap.Std.addr ->
Bap.Std.word -> 'b -> 'b Bap.Std.Memory_iterators.m) ->
'b Bap.Std.Memory_iterators.m
val iteri :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> unit Bap.Std.Memory_iterators.m) ->
unit Bap.Std.Memory_iterators.m
val exists :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
bool Bap.Std.Memory_iterators.m
val for_all :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
bool Bap.Std.Memory_iterators.m
val count :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
int Bap.Std.Memory_iterators.m
val find_if :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
Bap.Std.word option Bap.Std.Memory_iterators.m
val find_map :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> 'a option Bap.Std.Memory_iterators.m) ->
'a option Bap.Std.Memory_iterators.m
end
module Memory :
sig
type t = Bap.Std.mem
val sexp_of_t : t -> Sexplib.Sexp.t
val create :
?pos:int ->
?len:int ->
Bap.Std.endian ->
Bap.Std.addr ->
Core_kernel.Std.Bigstring.t ->
Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val of_file :
Bap.Std.endian ->
Bap.Std.addr ->
string -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val view :
?word_size:Bap.Std.size ->
?from:Bap.Std.addr ->
?words:int ->
Bap.Std.Memory.t -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val range :
Bap.Std.Memory.t ->
Bap.Std.addr ->
Bap.Std.addr -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val merge :
Bap.Std.Memory.t ->
Bap.Std.Memory.t -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val first_byte : Bap.Std.Memory.t -> Bap.Std.Memory.t
val last_byte : Bap.Std.Memory.t -> Bap.Std.Memory.t
val endian : Bap.Std.Memory.t -> Bap.Std.endian
val get :
?disp:int ->
?index:int ->
?scale:Bap.Std.size ->
?addr:Bap.Std.addr ->
Bap.Std.Memory.t -> Bap.Std.word Core_kernel.Std.Or_error.t
val ( ^ ) :
Bap.Std.Memory.t ->
Bap.Std.addr -> Bap.Std.word Core_kernel.Std.Or_error.t
val ( ^! ) : Bap.Std.Memory.t -> Bap.Std.addr -> Bap.Std.word
val max_addr : Bap.Std.Memory.t -> Bap.Std.addr
val min_addr : Bap.Std.Memory.t -> Bap.Std.addr
val length : Bap.Std.Memory.t -> int
val contains : Bap.Std.Memory.t -> Bap.Std.addr -> bool
val compare_with :
Bap.Std.Memory.t ->
Bap.Std.addr ->
[ `addr_is_above | `addr_is_below | `addr_is_inside ]
module Input :
sig
type 'a reader =
Bap.Std.Memory.t ->
pos_ref:Bap.Std.addr Core_kernel.Std.ref ->
'a Core_kernel.Std.Or_error.t
val word :
word_size:Bap.Std.size ->
Bap.Std.word Bap.Std.Memory.Input.reader
val int8 : Bap.Std.word Bap.Std.Memory.Input.reader
val uint8 : Bap.Std.word Bap.Std.Memory.Input.reader
val int16 : Bap.Std.word Bap.Std.Memory.Input.reader
val uint16 : Bap.Std.word Bap.Std.Memory.Input.reader
val int32 : Bap.Std.word Bap.Std.Memory.Input.reader
val int64 : Bap.Std.word Bap.Std.Memory.Input.reader
end
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val hexdump : Bap.Std.Memory.t -> string
type 'a m = 'a
val fold :
?word_size:size -> t -> init:'b -> f:(word -> 'b -> 'b) -> 'b
val iter : ?word_size:size -> t -> f:(word -> unit) -> unit
val foldi :
?word_size:size ->
t -> init:'b -> f:(addr -> word -> 'b -> 'b) -> 'b
val iteri :
?word_size:size -> t -> f:(addr -> word -> unit) -> unit
val exists :
?word_size:size -> t -> f:(addr -> word -> bool) -> bool
val for_all :
?word_size:size -> t -> f:(addr -> word -> bool) -> bool
val count : ?word_size:size -> t -> f:(addr -> word -> bool) -> int
val find_if :
?word_size:size -> t -> f:(addr -> word -> bool) -> word option
val find_map :
?word_size:size ->
t -> f:(addr -> word -> 'a option) -> 'a option
module With_error :
sig
type 'a m = 'a Core_kernel.Std.Or_error.t
val fold :
?word_size:size ->
t -> init:'b -> f:(word -> 'b -> 'b m) -> 'b m
val iter : ?word_size:size -> t -> f:(word -> unit m) -> unit m
val foldi :
?word_size:size ->
t -> init:'b -> f:(addr -> word -> 'b -> 'b m) -> 'b m
val iteri :
?word_size:size -> t -> f:(addr -> word -> unit m) -> unit m
val exists :
?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
val for_all :
?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
val count :
?word_size:size -> t -> f:(addr -> word -> bool m) -> int m
val find_if :
?word_size:size ->
t -> f:(addr -> word -> bool m) -> word option m
val find_map :
?word_size:size ->
t -> f:(addr -> word -> 'a option m) -> 'a option m
end
module Make_iterators :
functor (M : Legacy.Monad.S) ->
sig
type 'a m = 'a M.t
val fold :
?word_size:size ->
t -> init:'b -> f:(word -> 'b -> 'b m) -> 'b m
val iter :
?word_size:size -> t -> f:(word -> unit m) -> unit m
val foldi :
?word_size:size ->
t -> init:'b -> f:(addr -> word -> 'b -> 'b m) -> 'b m
val iteri :
?word_size:size ->
t -> f:(addr -> word -> unit m) -> unit m
val exists :
?word_size:size ->
t -> f:(addr -> word -> bool m) -> bool m
val for_all :
?word_size:size ->
t -> f:(addr -> word -> bool m) -> bool m
val count :
?word_size:size -> t -> f:(addr -> word -> bool m) -> int m
val find_if :
?word_size:size ->
t -> f:(addr -> word -> bool m) -> word option m
val find_map :
?word_size:size ->
t -> f:(addr -> word -> 'a option m) -> 'a option m
end
val to_buffer : Bap.Std.Memory.t -> Core_kernel.Std.Bigsubstring.t
module Trie :
sig
module Stable :
sig
module V1 :
sig
module R8 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t)
Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Bap.Std.mem
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match :
'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer ->
'a t Regular.Std.printer
end
module R16 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t)
Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = R8.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match :
'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer ->
'a t Regular.Std.printer
end
module R32 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t)
Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = R16.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match :
'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer ->
'a t Regular.Std.printer
end
module R64 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t)
Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = R32.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match :
'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer ->
'a t Regular.Std.printer
end
end
module V2 :
sig
module R8 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t)
Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = V1.R8.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match :
'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer ->
'a t Regular.Std.printer
end
module R16 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t)
Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = R8.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match :
'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer ->
'a t Regular.Std.printer
end
module R32 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t)
Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = R16.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match :
'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer ->
'a t Regular.Std.printer
end
module R64 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t)
Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = R32.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match :
'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer ->
'a t Regular.Std.printer
end
end
end
module R8 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = Stable.V2.R8.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module R16 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = R8.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module R32 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = R16.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
module R64 :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = R32.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
end
end
module Table :
sig
type 'a t = 'a Bap.Std.table
val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type 'a hashable = 'a Core_kernel.Std.Hashtbl.Hashable.t
val empty : 'a Bap.Std.Table.t
val singleton : Bap.Std.mem -> 'a -> 'a Bap.Std.Table.t
val add :
'a Bap.Std.Table.t ->
Bap.Std.mem ->
'a -> 'a Bap.Std.Table.t Core_kernel.Std.Or_error.t
val remove :
'a Bap.Std.Table.t -> Bap.Std.mem -> 'a Bap.Std.Table.t
val change :
'a Bap.Std.Table.t ->
Bap.Std.mem ->
f:((Bap.Std.mem * 'a) Bap.Std.seq ->
[ `ignore
| `rebind of Bap.Std.mem * 'a
| `remove
| `update of Bap.Std.mem * 'a -> 'a ]) ->
'a Bap.Std.Table.t
val length : 'a Bap.Std.Table.t -> int
val find : 'a Bap.Std.Table.t -> Bap.Std.mem -> 'a option
val find_addr :
'a Bap.Std.Table.t -> Bap.Std.addr -> (Bap.Std.mem * 'a) option
val intersections :
'a Bap.Std.Table.t ->
Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
val fold_intersections :
'a Bap.Std.Table.t ->
Bap.Std.mem -> init:'b -> f:(Bap.Std.mem -> 'a -> 'b -> 'b) -> 'b
val has_intersections : 'a Bap.Std.Table.t -> Bap.Std.mem -> bool
val mem : 'a Bap.Std.Table.t -> Bap.Std.mem -> bool
val next :
'a Bap.Std.Table.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) option
val prev :
'a Bap.Std.Table.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) option
val min : 'a Bap.Std.Table.t -> (Bap.Std.mem * 'a) option
val max : 'a Bap.Std.Table.t -> (Bap.Std.mem * 'a) option
type ('a, 'm) r
val many : ('a, 'a Bap.Std.seq) Bap.Std.Table.r
val at_least_one : ('a, 'a * 'a Bap.Std.seq) Bap.Std.Table.r
val one : ('a, 'a) Bap.Std.Table.r
val maybe_one : ('a, 'a option) Bap.Std.Table.r
val link :
one_to:('b, 'r) Bap.Std.Table.r ->
'a Bap.Std.Table.hashable ->
'a Bap.Std.Table.t -> 'b Bap.Std.Table.t -> 'a -> 'r
val rev_map :
one_to:(Bap.Std.mem, 'r) Bap.Std.Table.r ->
'a Bap.Std.Table.hashable ->
'a Bap.Std.Table.t -> ('a -> 'r) Core_kernel.Std.Or_error.t
type 'a ranged = ?start:Bap.Std.mem -> ?until:Bap.Std.mem -> 'a
val exists :
('a Bap.Std.Table.t -> f:('a -> bool) -> bool)
Bap.Std.Table.ranged
val for_all :
('a Bap.Std.Table.t -> f:('a -> bool) -> bool)
Bap.Std.Table.ranged
val existsi :
('a Bap.Std.Table.t -> f:(Bap.Std.mem -> 'a -> bool) -> bool)
Bap.Std.Table.ranged
val for_alli :
('a Bap.Std.Table.t -> f:(Bap.Std.mem -> 'a -> bool) -> bool)
Bap.Std.Table.ranged
val count :
('a Bap.Std.Table.t -> f:('a -> bool) -> int)
Bap.Std.Table.ranged
val find_if :
('a Bap.Std.Table.t -> f:('a -> bool) -> 'a option)
Bap.Std.Table.ranged
val find_map :
('a Bap.Std.Table.t -> f:('a -> 'b option) -> 'b option)
Bap.Std.Table.ranged
val fold :
('a Bap.Std.Table.t -> init:'b -> f:('a -> 'b -> 'b) -> 'b)
Bap.Std.Table.ranged
val iter :
('a Bap.Std.Table.t -> f:('a -> unit) -> unit)
Bap.Std.Table.ranged
val find_mapi :
('a Bap.Std.Table.t ->
f:(Bap.Std.mem -> 'a -> 'b option) -> 'b option)
Bap.Std.Table.ranged
val foldi :
('a Bap.Std.Table.t ->
init:'b -> f:(Bap.Std.mem -> 'a -> 'b -> 'b) -> 'b)
Bap.Std.Table.ranged
val iteri :
('a Bap.Std.Table.t -> f:(Bap.Std.mem -> 'a -> unit) -> unit)
Bap.Std.Table.ranged
val map :
('a Bap.Std.Table.t -> f:('a -> 'b) -> 'b Bap.Std.Table.t)
Bap.Std.Table.ranged
val mapi :
('a Bap.Std.Table.t ->
f:(Bap.Std.mem -> 'a -> 'b) -> 'b Bap.Std.Table.t)
Bap.Std.Table.ranged
val filter :
('a Bap.Std.Table.t -> f:('a -> bool) -> 'a Bap.Std.Table.t)
Bap.Std.Table.ranged
val filter_map :
('a Bap.Std.Table.t -> f:('a -> 'b option) -> 'b Bap.Std.Table.t)
Bap.Std.Table.ranged
val filteri :
('a Bap.Std.Table.t ->
f:(Bap.Std.mem -> 'a -> bool) -> 'a Bap.Std.Table.t)
Bap.Std.Table.ranged
val filter_mapi :
('a Bap.Std.Table.t ->
f:(Bap.Std.mem -> 'a -> 'b option) -> 'b Bap.Std.Table.t)
Bap.Std.Table.ranged
val to_sequence :
('a Bap.Std.Table.t -> (Bap.Std.mem * 'a) Bap.Std.seq)
Bap.Std.Table.ranged
val regions :
('a Bap.Std.Table.t -> Bap.Std.mem Bap.Std.seq)
Bap.Std.Table.ranged
val elements :
('a Bap.Std.Table.t -> 'a Bap.Std.seq) Bap.Std.Table.ranged
val pp :
'a Regular.Std.printer -> 'a Bap.Std.Table.t Regular.Std.printer
end
module Location :
sig
type t = { addr : Bap.Std.addr; len : int; }
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val len : t -> int
val addr : t -> addr
module Fields :
sig
val names : Trie.String.Suffix.key list
val len : (t, int) Fieldslib.Field.t
val addr : (t, addr) Fieldslib.Field.t
val fold :
init:'acc__0 ->
addr:('acc__0 -> (t, addr) Fieldslib.Field.t -> 'acc__1) ->
len:('acc__1 -> (t, int) Fieldslib.Field.t -> 'acc__2) ->
'acc__2
val make_creator :
addr:((t, addr) Fieldslib.Field.t ->
'acc__0 -> ('input__ -> addr) * 'acc__1) ->
len:((t, int) Fieldslib.Field.t ->
'acc__1 -> ('input__ -> int) * 'acc__2) ->
'acc__0 -> ('input__ -> t) * 'acc__2
val create : addr:addr -> len:int -> t
val map :
addr:((t, addr) Fieldslib.Field.t -> addr) ->
len:((t, int) Fieldslib.Field.t -> int) -> t
val iter :
addr:((t, addr) Fieldslib.Field.t -> unit) ->
len:((t, int) Fieldslib.Field.t -> unit) -> unit
val for_all :
addr:((t, addr) Fieldslib.Field.t -> bool) ->
len:((t, int) Fieldslib.Field.t -> bool) -> bool
val exists :
addr:((t, addr) Fieldslib.Field.t -> bool) ->
len:((t, int) Fieldslib.Field.t -> bool) -> bool
val to_list :
addr:((t, addr) Fieldslib.Field.t -> 'elem__) ->
len:((t, int) Fieldslib.Field.t -> 'elem__) -> 'elem__ list
val map_poly :
([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
'x0 list
module Direct :
sig
val iter :
t ->
addr:((t, addr) Fieldslib.Field.t -> t -> addr -> unit) ->
len:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
unit
val fold :
t ->
init:'acc__0 ->
addr:('acc__0 ->
(t, addr) Fieldslib.Field.t -> t -> addr -> 'acc__1) ->
len:('acc__1 ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__2) ->
'acc__2
val for_all :
t ->
addr:((t, addr) Fieldslib.Field.t -> t -> addr -> bool) ->
len:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
bool
val exists :
t ->
addr:((t, addr) Fieldslib.Field.t -> t -> addr -> bool) ->
len:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
bool
val to_list :
t ->
addr:((t, addr) Fieldslib.Field.t -> t -> addr -> 'elem__) ->
len:((t, int) Fieldslib.Field.t -> t -> int -> 'elem__) ->
'elem__ list
val map :
t ->
addr:((t, addr) Fieldslib.Field.t -> t -> addr -> addr) ->
len:((t, int) Fieldslib.Field.t -> t -> int -> int) -> t
val set_all_mutable_fields : t -> unit
end
end
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
type location = Bap.Std.Location.t
val bin_location : location Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_location : location Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_location__ :
(int -> location) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_location :
location Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_location : location Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_location : location Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_location :
location Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_location : Core_kernel.Std.Bin_prot.Shape.t
val compare_location : location -> location -> int
val location_of_sexp : Sexplib.Sexp.t -> location
val sexp_of_location : location -> Sexplib.Sexp.t
module Backend :
sig
type perm =
R
| W
| X
| Or of Bap.Std.Backend.perm * Bap.Std.Backend.perm
val bin_perm : perm Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_perm : perm Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_perm__ :
(int -> perm) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_perm :
perm Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_perm : perm Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_perm : perm Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_perm :
perm Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_perm : Core_kernel.Std.Bin_prot.Shape.t
val compare_perm : perm -> perm -> int
val perm_of_sexp : Sexplib.Sexp.t -> perm
val sexp_of_perm : perm -> Sexplib.Sexp.t
module Segment :
sig
type t = {
name : string;
perm : Bap.Std.Backend.perm;
off : int;
location : Bap.Std.location;
}
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val location : t -> location
val off : t -> int
val perm : t -> perm
val name : t -> Trie.String.Suffix.key
module Fields :
sig
val names : Trie.String.Suffix.key list
val location : (t, location) Fieldslib.Field.t
val off : (t, int) Fieldslib.Field.t
val perm : (t, perm) Fieldslib.Field.t
val name : (t, Trie.String.Suffix.key) Fieldslib.Field.t
val fold :
init:'acc__0 ->
name:('acc__0 ->
(t, Trie.String.Suffix.key) Fieldslib.Field.t ->
'acc__1) ->
perm:('acc__1 -> (t, perm) Fieldslib.Field.t -> 'acc__2) ->
off:('acc__2 -> (t, int) Fieldslib.Field.t -> 'acc__3) ->
location:('acc__3 ->
(t, location) Fieldslib.Field.t -> 'acc__4) ->
'acc__4
val make_creator :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
'acc__0 ->
('input__ -> Trie.String.Suffix.key) * 'acc__1) ->
perm:((t, perm) Fieldslib.Field.t ->
'acc__1 -> ('input__ -> perm) * 'acc__2) ->
off:((t, int) Fieldslib.Field.t ->
'acc__2 -> ('input__ -> int) * 'acc__3) ->
location:((t, location) Fieldslib.Field.t ->
'acc__3 -> ('input__ -> location) * 'acc__4) ->
'acc__0 -> ('input__ -> t) * 'acc__4
val create :
name:Trie.String.Suffix.key ->
perm:perm -> off:int -> location:location -> t
val map :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
Trie.String.Suffix.key) ->
perm:((t, perm) Fieldslib.Field.t -> perm) ->
off:((t, int) Fieldslib.Field.t -> int) ->
location:((t, location) Fieldslib.Field.t -> location) ->
t
val iter :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
unit) ->
perm:((t, perm) Fieldslib.Field.t -> unit) ->
off:((t, int) Fieldslib.Field.t -> unit) ->
location:((t, location) Fieldslib.Field.t -> unit) ->
unit
val for_all :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
bool) ->
perm:((t, perm) Fieldslib.Field.t -> bool) ->
off:((t, int) Fieldslib.Field.t -> bool) ->
location:((t, location) Fieldslib.Field.t -> bool) ->
bool
val exists :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
bool) ->
perm:((t, perm) Fieldslib.Field.t -> bool) ->
off:((t, int) Fieldslib.Field.t -> bool) ->
location:((t, location) Fieldslib.Field.t -> bool) ->
bool
val to_list :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
'elem__) ->
perm:((t, perm) Fieldslib.Field.t -> 'elem__) ->
off:((t, int) Fieldslib.Field.t -> 'elem__) ->
location:((t, location) Fieldslib.Field.t -> 'elem__) ->
'elem__ list
val map_poly :
([< `Read | `Set_and_create ], t, 'x0)
Fieldslib.Field.user -> 'x0 list
module Direct :
sig
val iter :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> unit) ->
perm:((t, perm) Fieldslib.Field.t ->
t -> perm -> unit) ->
off:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> unit) ->
unit
val fold :
t ->
init:'acc__0 ->
name:('acc__0 ->
(t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> 'acc__1) ->
perm:('acc__1 ->
(t, perm) Fieldslib.Field.t ->
t -> perm -> 'acc__2) ->
off:('acc__2 ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__3) ->
location:('acc__3 ->
(t, location) Fieldslib.Field.t ->
t -> location -> 'acc__4) ->
'acc__4
val for_all :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> bool) ->
perm:((t, perm) Fieldslib.Field.t ->
t -> perm -> bool) ->
off:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> bool) ->
bool
val exists :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> bool) ->
perm:((t, perm) Fieldslib.Field.t ->
t -> perm -> bool) ->
off:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> bool) ->
bool
val to_list :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> 'elem__) ->
perm:((t, perm) Fieldslib.Field.t ->
t -> perm -> 'elem__) ->
off:((t, int) Fieldslib.Field.t ->
t -> int -> 'elem__) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> 'elem__) ->
'elem__ list
val map :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t ->
Trie.String.Suffix.key ->
Trie.String.Suffix.key) ->
perm:((t, perm) Fieldslib.Field.t ->
t -> perm -> perm) ->
off:((t, int) Fieldslib.Field.t -> t -> int -> int) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> location) ->
t
val set_all_mutable_fields : t -> unit
end
end
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Symbol :
sig
type t = {
name : string;
is_function : bool;
is_debug : bool;
locations : Bap.Std.location * Bap.Std.location list;
}
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val locations : t -> location * location list
val is_debug : t -> bool
val is_function : t -> bool
val name : t -> Trie.String.Suffix.key
module Fields :
sig
val names : Trie.String.Suffix.key list
val locations :
(t, location * location list) Fieldslib.Field.t
val is_debug : (t, bool) Fieldslib.Field.t
val is_function : (t, bool) Fieldslib.Field.t
val name : (t, Trie.String.Suffix.key) Fieldslib.Field.t
val fold :
init:'acc__0 ->
name:('acc__0 ->
(t, Trie.String.Suffix.key) Fieldslib.Field.t ->
'acc__1) ->
is_function:('acc__1 ->
(t, bool) Fieldslib.Field.t -> 'acc__2) ->
is_debug:('acc__2 ->
(t, bool) Fieldslib.Field.t -> 'acc__3) ->
locations:('acc__3 ->
(t, location * location list)
Fieldslib.Field.t -> 'acc__4) ->
'acc__4
val make_creator :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
'acc__0 ->
('input__ -> Trie.String.Suffix.key) * 'acc__1) ->
is_function:((t, bool) Fieldslib.Field.t ->
'acc__1 -> ('input__ -> bool) * 'acc__2) ->
is_debug:((t, bool) Fieldslib.Field.t ->
'acc__2 -> ('input__ -> bool) * 'acc__3) ->
locations:((t, location * location list)
Fieldslib.Field.t ->
'acc__3 ->
('input__ -> location * location list) *
'acc__4) ->
'acc__0 -> ('input__ -> t) * 'acc__4
val create :
name:Trie.String.Suffix.key ->
is_function:bool ->
is_debug:bool -> locations:location * location list -> t
val map :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
Trie.String.Suffix.key) ->
is_function:((t, bool) Fieldslib.Field.t -> bool) ->
is_debug:((t, bool) Fieldslib.Field.t -> bool) ->
locations:((t, location * location list)
Fieldslib.Field.t -> location * location list) ->
t
val iter :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
unit) ->
is_function:((t, bool) Fieldslib.Field.t -> unit) ->
is_debug:((t, bool) Fieldslib.Field.t -> unit) ->
locations:((t, location * location list)
Fieldslib.Field.t -> unit) ->
unit
val for_all :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
bool) ->
is_function:((t, bool) Fieldslib.Field.t -> bool) ->
is_debug:((t, bool) Fieldslib.Field.t -> bool) ->
locations:((t, location * location list)
Fieldslib.Field.t -> bool) ->
bool
val exists :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
bool) ->
is_function:((t, bool) Fieldslib.Field.t -> bool) ->
is_debug:((t, bool) Fieldslib.Field.t -> bool) ->
locations:((t, location * location list)
Fieldslib.Field.t -> bool) ->
bool
val to_list :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
'elem__) ->
is_function:((t, bool) Fieldslib.Field.t -> 'elem__) ->
is_debug:((t, bool) Fieldslib.Field.t -> 'elem__) ->
locations:((t, location * location list)
Fieldslib.Field.t -> 'elem__) ->
'elem__ list
val map_poly :
([< `Read | `Set_and_create ], t, 'x0)
Fieldslib.Field.user -> 'x0 list
module Direct :
sig
val iter :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> unit) ->
is_function:((t, bool) Fieldslib.Field.t ->
t -> bool -> unit) ->
is_debug:((t, bool) Fieldslib.Field.t ->
t -> bool -> unit) ->
locations:((t, location * location list)
Fieldslib.Field.t ->
t -> location * location list -> unit) ->
unit
val fold :
t ->
init:'acc__0 ->
name:('acc__0 ->
(t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> 'acc__1) ->
is_function:('acc__1 ->
(t, bool) Fieldslib.Field.t ->
t -> bool -> 'acc__2) ->
is_debug:('acc__2 ->
(t, bool) Fieldslib.Field.t ->
t -> bool -> 'acc__3) ->
locations:('acc__3 ->
(t, location * location list)
Fieldslib.Field.t ->
t -> location * location list -> 'acc__4) ->
'acc__4
val for_all :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> bool) ->
is_function:((t, bool) Fieldslib.Field.t ->
t -> bool -> bool) ->
is_debug:((t, bool) Fieldslib.Field.t ->
t -> bool -> bool) ->
locations:((t, location * location list)
Fieldslib.Field.t ->
t -> location * location list -> bool) ->
bool
val exists :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> bool) ->
is_function:((t, bool) Fieldslib.Field.t ->
t -> bool -> bool) ->
is_debug:((t, bool) Fieldslib.Field.t ->
t -> bool -> bool) ->
locations:((t, location * location list)
Fieldslib.Field.t ->
t -> location * location list -> bool) ->
bool
val to_list :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> 'elem__) ->
is_function:((t, bool) Fieldslib.Field.t ->
t -> bool -> 'elem__) ->
is_debug:((t, bool) Fieldslib.Field.t ->
t -> bool -> 'elem__) ->
locations:((t, location * location list)
Fieldslib.Field.t ->
t -> location * location list -> 'elem__) ->
'elem__ list
val map :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t ->
Trie.String.Suffix.key ->
Trie.String.Suffix.key) ->
is_function:((t, bool) Fieldslib.Field.t ->
t -> bool -> bool) ->
is_debug:((t, bool) Fieldslib.Field.t ->
t -> bool -> bool) ->
locations:((t, location * location list)
Fieldslib.Field.t ->
t ->
location * location list ->
location * location list) ->
t
val set_all_mutable_fields : t -> unit
end
end
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Section :
sig
type t = { name : string; location : Bap.Std.location; }
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val location : t -> location
val name : t -> Trie.String.Suffix.key
module Fields :
sig
val names : Trie.String.Suffix.key list
val location : (t, location) Fieldslib.Field.t
val name : (t, Trie.String.Suffix.key) Fieldslib.Field.t
val fold :
init:'acc__0 ->
name:('acc__0 ->
(t, Trie.String.Suffix.key) Fieldslib.Field.t ->
'acc__1) ->
location:('acc__1 ->
(t, location) Fieldslib.Field.t -> 'acc__2) ->
'acc__2
val make_creator :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
'acc__0 ->
('input__ -> Trie.String.Suffix.key) * 'acc__1) ->
location:((t, location) Fieldslib.Field.t ->
'acc__1 -> ('input__ -> location) * 'acc__2) ->
'acc__0 -> ('input__ -> t) * 'acc__2
val create :
name:Trie.String.Suffix.key -> location:location -> t
val map :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
Trie.String.Suffix.key) ->
location:((t, location) Fieldslib.Field.t -> location) ->
t
val iter :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
unit) ->
location:((t, location) Fieldslib.Field.t -> unit) ->
unit
val for_all :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
bool) ->
location:((t, location) Fieldslib.Field.t -> bool) ->
bool
val exists :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
bool) ->
location:((t, location) Fieldslib.Field.t -> bool) ->
bool
val to_list :
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
'elem__) ->
location:((t, location) Fieldslib.Field.t -> 'elem__) ->
'elem__ list
val map_poly :
([< `Read | `Set_and_create ], t, 'x0)
Fieldslib.Field.user -> 'x0 list
module Direct :
sig
val iter :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> unit) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> unit) ->
unit
val fold :
t ->
init:'acc__0 ->
name:('acc__0 ->
(t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> 'acc__1) ->
location:('acc__1 ->
(t, location) Fieldslib.Field.t ->
t -> location -> 'acc__2) ->
'acc__2
val for_all :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> bool) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> bool) ->
bool
val exists :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> bool) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> bool) ->
bool
val to_list :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t -> Trie.String.Suffix.key -> 'elem__) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> 'elem__) ->
'elem__ list
val map :
t ->
name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
t ->
Trie.String.Suffix.key ->
Trie.String.Suffix.key) ->
location:((t, location) Fieldslib.Field.t ->
t -> location -> location) ->
t
val set_all_mutable_fields : t -> unit
end
end
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Img :
sig
type t = {
arch : Bap.Std.arch;
entry : Bap.Std.addr;
segments :
Bap.Std.Backend.Segment.t * Bap.Std.Backend.Segment.t list;
symbols : Bap.Std.Backend.Symbol.t list;
sections : Bap.Std.Backend.Section.t list;
}
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val sections : t -> Section.t list
val symbols : t -> Symbol.t list
val segments : t -> Segment.t * Segment.t list
val entry : t -> addr
val arch : t -> arch
module Fields :
sig
val names : Trie.String.Suffix.key list
val sections : (t, Section.t list) Fieldslib.Field.t
val symbols : (t, Symbol.t list) Fieldslib.Field.t
val segments :
(t, Segment.t * Segment.t list) Fieldslib.Field.t
val entry : (t, addr) Fieldslib.Field.t
val arch : (t, arch) Fieldslib.Field.t
val fold :
init:'acc__0 ->
arch:('acc__0 -> (t, arch) Fieldslib.Field.t -> 'acc__1) ->
entry:('acc__1 -> (t, addr) Fieldslib.Field.t -> 'acc__2) ->
segments:('acc__2 ->
(t, Segment.t * Segment.t list)
Fieldslib.Field.t -> 'acc__3) ->
symbols:('acc__3 ->
(t, Symbol.t list) Fieldslib.Field.t -> 'acc__4) ->
sections:('acc__4 ->
(t, Section.t list) Fieldslib.Field.t ->
'acc__5) ->
'acc__5
val make_creator :
arch:((t, arch) Fieldslib.Field.t ->
'acc__0 -> ('input__ -> arch) * 'acc__1) ->
entry:((t, addr) Fieldslib.Field.t ->
'acc__1 -> ('input__ -> addr) * 'acc__2) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t ->
'acc__2 ->
('input__ -> Segment.t * Segment.t list) *
'acc__3) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t ->
'acc__3 -> ('input__ -> Symbol.t list) * 'acc__4) ->
sections:((t, Section.t list) Fieldslib.Field.t ->
'acc__4 ->
('input__ -> Section.t list) * 'acc__5) ->
'acc__0 -> ('input__ -> t) * 'acc__5
val create :
arch:arch ->
entry:addr ->
segments:Segment.t * Segment.t list ->
symbols:Symbol.t list -> sections:Section.t list -> t
val map :
arch:((t, arch) Fieldslib.Field.t -> arch) ->
entry:((t, addr) Fieldslib.Field.t -> addr) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t -> Segment.t * Segment.t list) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t ->
Symbol.t list) ->
sections:((t, Section.t list) Fieldslib.Field.t ->
Section.t list) ->
t
val iter :
arch:((t, arch) Fieldslib.Field.t -> unit) ->
entry:((t, addr) Fieldslib.Field.t -> unit) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t -> unit) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t -> unit) ->
sections:((t, Section.t list) Fieldslib.Field.t -> unit) ->
unit
val for_all :
arch:((t, arch) Fieldslib.Field.t -> bool) ->
entry:((t, addr) Fieldslib.Field.t -> bool) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t -> bool) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t -> bool) ->
sections:((t, Section.t list) Fieldslib.Field.t -> bool) ->
bool
val exists :
arch:((t, arch) Fieldslib.Field.t -> bool) ->
entry:((t, addr) Fieldslib.Field.t -> bool) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t -> bool) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t -> bool) ->
sections:((t, Section.t list) Fieldslib.Field.t -> bool) ->
bool
val to_list :
arch:((t, arch) Fieldslib.Field.t -> 'elem__) ->
entry:((t, addr) Fieldslib.Field.t -> 'elem__) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t -> 'elem__) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t -> 'elem__) ->
sections:((t, Section.t list) Fieldslib.Field.t ->
'elem__) ->
'elem__ list
val map_poly :
([< `Read | `Set_and_create ], t, 'x0)
Fieldslib.Field.user -> 'x0 list
module Direct :
sig
val iter :
t ->
arch:((t, arch) Fieldslib.Field.t ->
t -> arch -> unit) ->
entry:((t, addr) Fieldslib.Field.t ->
t -> addr -> unit) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t ->
t -> Segment.t * Segment.t list -> unit) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t ->
t -> Symbol.t list -> unit) ->
sections:((t, Section.t list) Fieldslib.Field.t ->
t -> Section.t list -> unit) ->
unit
val fold :
t ->
init:'acc__0 ->
arch:('acc__0 ->
(t, arch) Fieldslib.Field.t ->
t -> arch -> 'acc__1) ->
entry:('acc__1 ->
(t, addr) Fieldslib.Field.t ->
t -> addr -> 'acc__2) ->
segments:('acc__2 ->
(t, Segment.t * Segment.t list)
Fieldslib.Field.t ->
t -> Segment.t * Segment.t list -> 'acc__3) ->
symbols:('acc__3 ->
(t, Symbol.t list) Fieldslib.Field.t ->
t -> Symbol.t list -> 'acc__4) ->
sections:('acc__4 ->
(t, Section.t list) Fieldslib.Field.t ->
t -> Section.t list -> 'acc__5) ->
'acc__5
val for_all :
t ->
arch:((t, arch) Fieldslib.Field.t ->
t -> arch -> bool) ->
entry:((t, addr) Fieldslib.Field.t ->
t -> addr -> bool) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t ->
t -> Segment.t * Segment.t list -> bool) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t ->
t -> Symbol.t list -> bool) ->
sections:((t, Section.t list) Fieldslib.Field.t ->
t -> Section.t list -> bool) ->
bool
val exists :
t ->
arch:((t, arch) Fieldslib.Field.t ->
t -> arch -> bool) ->
entry:((t, addr) Fieldslib.Field.t ->
t -> addr -> bool) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t ->
t -> Segment.t * Segment.t list -> bool) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t ->
t -> Symbol.t list -> bool) ->
sections:((t, Section.t list) Fieldslib.Field.t ->
t -> Section.t list -> bool) ->
bool
val to_list :
t ->
arch:((t, arch) Fieldslib.Field.t ->
t -> arch -> 'elem__) ->
entry:((t, addr) Fieldslib.Field.t ->
t -> addr -> 'elem__) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t ->
t -> Segment.t * Segment.t list -> 'elem__) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t ->
t -> Symbol.t list -> 'elem__) ->
sections:((t, Section.t list) Fieldslib.Field.t ->
t -> Section.t list -> 'elem__) ->
'elem__ list
val map :
t ->
arch:((t, arch) Fieldslib.Field.t ->
t -> arch -> arch) ->
entry:((t, addr) Fieldslib.Field.t ->
t -> addr -> addr) ->
segments:((t, Segment.t * Segment.t list)
Fieldslib.Field.t ->
t ->
Segment.t * Segment.t list ->
Segment.t * Segment.t list) ->
symbols:((t, Symbol.t list) Fieldslib.Field.t ->
t -> Symbol.t list -> Symbol.t list) ->
sections:((t, Section.t list) Fieldslib.Field.t ->
t -> Section.t list -> Section.t list) ->
t
val set_all_mutable_fields : t -> unit
end
end
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
type t =
Core_kernel.Std.Bigstring.t -> Bap.Std.Backend.Img.t option
end
module Image :
sig
type t = Bap.Std.image
val sexp_of_t : t -> Sexplib.Sexp.t
type segment
val bin_segment : segment Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_segment : segment Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_segment__ :
(int -> segment) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_segment :
segment Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_segment : segment Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_segment :
segment Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_segment :
segment Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_segment : Core_kernel.Std.Bin_prot.Shape.t
val compare_segment : segment -> segment -> int
val segment_of_sexp : Sexplib.Sexp.t -> segment
val sexp_of_segment : segment -> Sexplib.Sexp.t
type symbol
val bin_symbol : symbol Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_symbol : symbol Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_symbol__ :
(int -> symbol) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_symbol :
symbol Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_symbol : symbol Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_symbol : symbol Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_symbol :
symbol Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_symbol : Core_kernel.Std.Bin_prot.Shape.t
val compare_symbol : symbol -> symbol -> int
val symbol_of_sexp : Sexplib.Sexp.t -> symbol
val sexp_of_symbol : symbol -> Sexplib.Sexp.t
type path = string
type result =
(Bap.Std.Image.t * Core_kernel.Std.Error.t list)
Core_kernel.Std.Or_error.t
val create :
?backend:string -> Bap.Std.Image.path -> Bap.Std.Image.result
val of_string : ?backend:string -> string -> Bap.Std.Image.result
val of_bigstring :
?backend:string ->
Core_kernel.Std.Bigstring.t -> Bap.Std.Image.result
val entry_point : Bap.Std.Image.t -> Bap.Std.addr
val filename : Bap.Std.Image.t -> string option
val arch : Bap.Std.Image.t -> Bap.Std.arch
val addr_size : Bap.Std.Image.t -> Bap.Std.addr_size
val endian : Bap.Std.Image.t -> Bap.Std.endian
val words :
Bap.Std.Image.t -> Bap.Std.size -> Bap.Std.word Bap.Std.table
val segments :
Bap.Std.Image.t -> Bap.Std.Image.segment Bap.Std.table
val symbols : Bap.Std.Image.t -> Bap.Std.Image.symbol Bap.Std.table
val segment : Bap.Std.Image.segment Bap.Std.tag
val symbol : string Bap.Std.tag
val section : string Bap.Std.tag
val specification : Ogre.doc Bap.Std.tag
val memory : Bap.Std.Image.t -> Bap.Std.value Bap.Std.memmap
val memory_of_segment :
Bap.Std.Image.t -> Bap.Std.Image.segment -> Bap.Std.mem
val memory_of_symbol :
Bap.Std.Image.t ->
Bap.Std.Image.symbol -> Bap.Std.mem * Bap.Std.mem Bap.Std.seq
val symbols_of_segment :
Bap.Std.Image.t ->
Bap.Std.Image.segment -> Bap.Std.Image.symbol Bap.Std.seq
val segment_of_symbol :
Bap.Std.Image.t -> Bap.Std.Image.symbol -> Bap.Std.Image.segment
module Segment :
sig
type t = Bap.Std.Image.segment
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.Image.segment
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Value.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key *
[ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t ->
(unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val name : Bap.Std.Image.Segment.t -> string
val is_writable : Bap.Std.Image.Segment.t -> bool
val is_readable : Bap.Std.Image.Segment.t -> bool
val is_executable : Bap.Std.Image.Segment.t -> bool
end
module Symbol :
sig
type t = Bap.Std.Image.symbol
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.Image.symbol
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Segment.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key *
[ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t ->
(unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val name : Bap.Std.Image.Symbol.t -> string
val is_function : Bap.Std.Image.Symbol.t -> bool
val is_debug : Bap.Std.Image.Symbol.t -> bool
end
module type Loader =
sig
val from_file :
string -> Ogre.doc option Core_kernel.Std.Or_error.t
val from_data :
Core_kernel.Std.Bigstring.t ->
Ogre.doc option Core_kernel.Std.Or_error.t
end
val register_loader :
name:string -> (module Bap.Std.Image.Loader) -> unit
val available_backends : unit -> string list
val register_backend :
name:string -> Bap.Std.Backend.t -> [ `Duplicate | `Ok ]
val data : Bap.Std.Image.t -> Core_kernel.Std.Bigstring.t
val spec : Bap.Std.Image.t -> Ogre.doc
module Scheme :
sig
type addr = int64
type size = int64
type off = int64
type 'a region = {
addr : Bap.Std.Image.Scheme.addr;
size : Bap.Std.Image.Scheme.size;
info : 'a;
}
val off : Bap.Std.Image.Scheme.off Ogre.field
val size : Bap.Std.Image.Scheme.size Ogre.field
val addr : Bap.Std.Image.Scheme.addr Ogre.field
val name : string Ogre.field
val root : Bap.Std.Image.Scheme.addr Ogre.field
val readable : bool Ogre.field
val writable : bool Ogre.field
val executable : bool Ogre.field
val fixup : Bap.Std.Image.Scheme.addr Ogre.field
val arch : (string, (string -> 'a) -> 'a) Ogre.attribute
val segment :
((bool * bool * bool) Bap.Std.Image.Scheme.region,
(Bap.Std.Image.Scheme.addr ->
Bap.Std.Image.Scheme.size -> bool -> bool -> bool -> 'a) ->
'a)
Ogre.attribute
val section :
(unit Bap.Std.Image.Scheme.region,
(Bap.Std.Image.Scheme.addr ->
Bap.Std.Image.Scheme.size -> 'a) ->
'a)
Ogre.attribute
val code_start :
(Bap.Std.Image.Scheme.addr,
(Bap.Std.Image.Scheme.addr -> 'a) -> 'a)
Ogre.attribute
val entry_point :
(Bap.Std.Image.Scheme.addr,
(Bap.Std.Image.Scheme.addr -> 'a) -> 'a)
Ogre.attribute
val symbol_chunk :
(Bap.Std.Image.Scheme.addr Bap.Std.Image.Scheme.region,
(Bap.Std.Image.Scheme.addr ->
Bap.Std.Image.Scheme.size ->
Bap.Std.Image.Scheme.addr -> 'a) ->
'a)
Ogre.attribute
val named_region :
(string Bap.Std.Image.Scheme.region,
(Bap.Std.Image.Scheme.addr ->
Bap.Std.Image.Scheme.size -> string -> 'a) ->
'a)
Ogre.attribute
val named_symbol :
(Bap.Std.Image.Scheme.addr * string,
(Bap.Std.Image.Scheme.addr -> string -> 'a) -> 'a)
Ogre.attribute
val mapped :
(Bap.Std.Image.Scheme.off Bap.Std.Image.Scheme.region,
(Bap.Std.Image.Scheme.addr ->
Bap.Std.Image.Scheme.size -> Bap.Std.Image.Scheme.off -> 'a) ->
'a)
Ogre.attribute
val relocation :
(int64 * Bap.Std.Image.Scheme.addr,
(Bap.Std.Image.Scheme.addr ->
Bap.Std.Image.Scheme.addr -> 'a) ->
'a)
Ogre.attribute
val external_reference :
(Bap.Std.Image.Scheme.addr * string,
(Bap.Std.Image.Scheme.addr -> string -> 'a) -> 'a)
Ogre.attribute
val base_address :
(Bap.Std.Image.Scheme.addr,
(Bap.Std.Image.Scheme.addr -> 'a) -> 'a)
Ogre.attribute
end
end
module Memmap :
sig
type 'a t = 'a Bap.Std.memmap
val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val empty : 'a Bap.Std.Memmap.t
val singleton : Bap.Std.mem -> 'a -> 'a Bap.Std.Memmap.t
val min_addr : 'a Bap.Std.Memmap.t -> Bap.Std.addr option
val max_addr : 'a Bap.Std.Memmap.t -> Bap.Std.addr option
val min_binding : 'a Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) option
val max_binding : 'a Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) option
val add :
'a Bap.Std.Memmap.t -> Bap.Std.mem -> 'a -> 'a Bap.Std.Memmap.t
val dominators :
'a Bap.Std.Memmap.t ->
Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
val intersections :
'a Bap.Std.Memmap.t ->
Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
val intersects : 'a Bap.Std.Memmap.t -> Bap.Std.mem -> bool
val dominates : 'a Bap.Std.Memmap.t -> Bap.Std.mem -> bool
val contains : 'a Bap.Std.Memmap.t -> Bap.Std.addr -> bool
val lookup :
'a Bap.Std.Memmap.t ->
Bap.Std.addr -> (Bap.Std.mem * 'a) Bap.Std.seq
val map :
'a Bap.Std.Memmap.t -> f:('a -> 'b) -> 'b Bap.Std.Memmap.t
val mapi :
'a Bap.Std.Memmap.t ->
f:(Bap.Std.mem -> 'a -> 'b) -> 'b Bap.Std.Memmap.t
val filter :
'a Bap.Std.Memmap.t -> f:('a -> bool) -> 'a Bap.Std.Memmap.t
val filter_map :
'a Bap.Std.Memmap.t -> f:('a -> 'b option) -> 'b Bap.Std.Memmap.t
val filter_mapi :
'a Bap.Std.Memmap.t ->
f:(Bap.Std.mem -> 'a -> 'b option) -> 'b Bap.Std.Memmap.t
val remove :
'a Bap.Std.Memmap.t -> Bap.Std.mem -> 'a Bap.Std.Memmap.t
val remove_intersections :
'a Bap.Std.Memmap.t -> Bap.Std.mem -> 'a Bap.Std.Memmap.t
val remove_dominators :
'a Bap.Std.Memmap.t -> Bap.Std.mem -> 'a Bap.Std.Memmap.t
val to_sequence :
'a Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) Bap.Std.seq
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a -> ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop) Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val pp :
'a Regular.Std.printer -> 'a Bap.Std.Memmap.t Regular.Std.printer
end
type symbolizer
type rooter
type brancher
type reconstructor
type disasm
type insn
val bin_insn : insn Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_insn : insn Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_insn__ :
(int -> insn) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_insn : insn Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_insn : insn Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_insn : insn Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_insn : insn Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_insn : Core_kernel.Std.Bin_prot.Shape.t
val compare_insn : insn -> insn -> int
val sexp_of_insn : insn -> Sexplib.Sexp.t
type block
val compare_block : block -> block -> int
val sexp_of_block : block -> Sexplib.Sexp.t
type cfg
val compare_cfg : cfg -> cfg -> int
type jump = [ `Cond | `Jump ]
val compare_jump : jump -> jump -> int
val jump_of_sexp : Sexplib.Sexp.t -> jump
val __jump_of_sexp__ : Sexplib.Sexp.t -> jump
val sexp_of_jump : jump -> Sexplib.Sexp.t
type edge = [ `Cond | `Fall | `Jump ]
val compare_edge : edge -> edge -> int
val edge_of_sexp : Sexplib.Sexp.t -> edge
val __edge_of_sexp__ : Sexplib.Sexp.t -> edge
val sexp_of_edge : edge -> Sexplib.Sexp.t
module Kind :
sig
type branch =
[ `Conditional_branch
| `Indirect_branch
| `Unconditional_branch ]
val bin_branch : branch Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_branch : branch Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_branch__ :
(int -> branch) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_branch :
branch Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_branch : branch Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_branch : branch Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_branch :
branch Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_branch : Core_kernel.Std.Bin_prot.Shape.t
val compare_branch : branch -> branch -> int
val all_of_branch : branch list
val branch_of_sexp : Sexplib.Sexp.t -> branch
val __branch_of_sexp__ : Sexplib.Sexp.t -> branch
val sexp_of_branch : branch -> Sexplib.Sexp.t
type affecting_control =
[ `Barrier
| `Call
| `Conditional_branch
| `Indirect_branch
| `May_affect_control_flow
| `Return
| `Terminator
| `Unconditional_branch ]
val bin_affecting_control :
affecting_control Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_affecting_control :
affecting_control Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_affecting_control__ :
(int -> affecting_control) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_affecting_control :
affecting_control Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_affecting_control :
affecting_control Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_affecting_control :
affecting_control Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_affecting_control :
affecting_control Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_affecting_control : Core_kernel.Std.Bin_prot.Shape.t
val compare_affecting_control :
affecting_control -> affecting_control -> int
val all_of_affecting_control : affecting_control list
val affecting_control_of_sexp : Sexplib.Sexp.t -> affecting_control
val __affecting_control_of_sexp__ :
Sexplib.Sexp.t -> affecting_control
val sexp_of_affecting_control : affecting_control -> Sexplib.Sexp.t
type having_side_effect = [ `May_load | `May_store ]
val bin_having_side_effect :
having_side_effect Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_having_side_effect :
having_side_effect Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_having_side_effect__ :
(int -> having_side_effect) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_having_side_effect :
having_side_effect Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_having_side_effect :
having_side_effect Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_having_side_effect :
having_side_effect Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_having_side_effect :
having_side_effect Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_having_side_effect : Core_kernel.Std.Bin_prot.Shape.t
val compare_having_side_effect :
having_side_effect -> having_side_effect -> int
val all_of_having_side_effect : having_side_effect list
val having_side_effect_of_sexp :
Sexplib.Sexp.t -> having_side_effect
val __having_side_effect_of_sexp__ :
Sexplib.Sexp.t -> having_side_effect
val sexp_of_having_side_effect :
having_side_effect -> Sexplib.Sexp.t
type t =
[ `Barrier
| `Call
| `Conditional_branch
| `Indirect_branch
| `May_affect_control_flow
| `May_load
| `May_store
| `Return
| `Terminator
| `Unconditional_branch ]
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val compare : t -> t -> int
val all : t list
val t_of_sexp : Sexplib.Sexp.t -> t
val __t_of_sexp__ : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
type reg
val bin_reg : reg Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_reg : reg Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_reg__ :
(int -> reg) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_reg : reg Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_reg : reg Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_reg : reg Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_reg : reg Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_reg : Core_kernel.Std.Bin_prot.Shape.t
val compare_reg : reg -> reg -> int
val reg_of_sexp : Sexplib.Sexp.t -> reg
val sexp_of_reg : reg -> Sexplib.Sexp.t
type imm
val bin_imm : imm Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_imm : imm Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_imm__ :
(int -> imm) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_imm : imm Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_imm : imm Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_imm : imm Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_imm : imm Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_imm : Core_kernel.Std.Bin_prot.Shape.t
val compare_imm : imm -> imm -> int
val imm_of_sexp : Sexplib.Sexp.t -> imm
val sexp_of_imm : imm -> Sexplib.Sexp.t
type fmm
val bin_fmm : fmm Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_fmm : fmm Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_fmm__ :
(int -> fmm) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_fmm : fmm Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_fmm : fmm Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_fmm : fmm Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_fmm : fmm Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_fmm : Core_kernel.Std.Bin_prot.Shape.t
val compare_fmm : fmm -> fmm -> int
val fmm_of_sexp : Sexplib.Sexp.t -> fmm
val sexp_of_fmm : fmm -> Sexplib.Sexp.t
type kind = Bap.Std.Kind.t
val bin_kind : kind Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_kind : kind Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_kind__ :
(int -> kind) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_kind : kind Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_kind : kind Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_kind : kind Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_kind : kind Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_kind : Core_kernel.Std.Bin_prot.Shape.t
val compare_kind : kind -> kind -> int
val kind_of_sexp : Sexplib.Sexp.t -> kind
val sexp_of_kind : kind -> Sexplib.Sexp.t
module Reg :
sig
type t = Bap.Std.reg
val code : Bap.Std.Reg.t -> int
val name : Bap.Std.Reg.t -> string
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.reg
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Value.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Imm :
sig
type t = Bap.Std.imm
val to_word : Bap.Std.Imm.t -> width:int -> Bap.Std.word option
val to_int64 : Bap.Std.Imm.t -> int64
val to_int : Bap.Std.Imm.t -> int option
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.imm
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Reg.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Fmm :
sig
type t = Bap.Std.fmm
val to_float : Bap.Std.Fmm.t -> float
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.fmm
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Imm.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Op :
sig
type t =
Reg of Bap.Std.reg
| Imm of Bap.Std.imm
| Fmm of Bap.Std.fmm
module Normalized :
sig
val compare : Bap.Std.Op.t -> Bap.Std.Op.t -> int
val hash : Bap.Std.Op.t -> int
val compare_ops :
Bap.Std.Op.t array -> Bap.Std.Op.t array -> int
end
val pp_adt : Format.formatter -> Bap.Std.Op.t -> unit
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Fmm.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
type op = Bap.Std.Op.t
val bin_op : op Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_op : op Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_op__ : (int -> op) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_op : op Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_op : op Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_op : op Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_op : op Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_op : Core_kernel.Std.Bin_prot.Shape.t
val compare_op : op -> op -> int
val sexp_of_op : op -> Sexplib.Sexp.t
module Disasm_expert :
sig
module Basic :
sig
type pred =
[ `Barrier
| `Call
| `Conditional_branch
| `Indirect_branch
| `May_affect_control_flow
| `May_load
| `May_store
| `Return
| `Terminator
| `Unconditional_branch
| `Valid ]
val pred_of_sexp : Sexplib.Sexp.t -> pred
val __pred_of_sexp__ : Sexplib.Sexp.t -> pred
val sexp_of_pred : pred -> Sexplib.Sexp.t
type (+'a, +'k) insn
type ('a, 'k) insns =
(Bap.Std.mem *
('a, 'k) Bap.Std.Disasm_expert.Basic.insn option)
list
type empty
type asm
type kinds
type full_insn =
(Bap.Std.Disasm_expert.Basic.asm,
Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.insn
val compare_full_insn : full_insn -> full_insn -> int
val sexp_of_full_insn : full_insn -> Sexplib.Sexp.t
type ('a, 'k) t
type (+'a, +'k, 's, 'r) state
val with_disasm :
?debug_level:int ->
?cpu:string ->
backend:string ->
string ->
f:((Bap.Std.Disasm_expert.Basic.empty,
Bap.Std.Disasm_expert.Basic.empty)
Bap.Std.Disasm_expert.Basic.t ->
'a Core_kernel.Std.Or_error.t) ->
'a Core_kernel.Std.Or_error.t
val create :
?debug_level:int ->
?cpu:string ->
backend:string ->
string ->
(Bap.Std.Disasm_expert.Basic.empty,
Bap.Std.Disasm_expert.Basic.empty)
Bap.Std.Disasm_expert.Basic.t Core_kernel.Std.Or_error.t
val close : ('a, 'b) Bap.Std.Disasm_expert.Basic.t -> unit
val store_asm :
('a, 'k) Bap.Std.Disasm_expert.Basic.t ->
(Bap.Std.Disasm_expert.Basic.asm, 'k)
Bap.Std.Disasm_expert.Basic.t
val store_kinds :
('a, 'b) Bap.Std.Disasm_expert.Basic.t ->
('a, Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.t
val run :
?backlog:int ->
?stop_on:Bap.Std.Disasm_expert.Basic.pred list ->
?invalid:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.mem -> 's -> 'r) ->
?stopped:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
's -> 'r) ->
?hit:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.mem ->
(Bap.Std.Disasm_expert.Basic.asm,
Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.insn -> 's -> 'r) ->
('a, 'k) Bap.Std.Disasm_expert.Basic.t ->
return:('s -> 'r) -> init:'s -> Bap.Std.mem -> 'r
val insn_of_mem :
('a, 'b) Bap.Std.Disasm_expert.Basic.t ->
Bap.Std.mem ->
(Bap.Std.mem *
(Bap.Std.Disasm_expert.Basic.asm,
Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.insn option *
[ `finished | `left of Bap.Std.mem ])
Core_kernel.Std.Or_error.t
val addr :
('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.addr
val preds :
('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.Disasm_expert.Basic.pred list
val with_preds :
('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.Disasm_expert.Basic.pred list ->
('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state
val insns :
('a, 'k, 'b, 'c) Bap.Std.Disasm_expert.Basic.state ->
('a, 'k) Bap.Std.Disasm_expert.Basic.insns
val last :
('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
int -> ('a, 'k) Bap.Std.Disasm_expert.Basic.insns
val memory :
('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.mem
val stop :
('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
's -> 'r
val step :
('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
's -> 'r
val jump :
('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.mem -> 's -> 'r
val back :
('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
's -> 'r
module Insn :
sig
type ('a, 'k) t = ('a, 'k) Bap.Std.Disasm_expert.Basic.insn
val sexp_of_t :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
Core_kernel.Std.Sexp.t
val compare :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> int
val code :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> int
val name :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> string
val kinds :
('a, Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.Insn.t -> Bap.Std.Kind.t list
val is :
('a, Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.Insn.t ->
Bap.Std.Kind.t -> bool
val asm :
(Bap.Std.Disasm_expert.Basic.asm, 'k)
Bap.Std.Disasm_expert.Basic.Insn.t -> string
val ops :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
Bap.Std.op array
end
module Trie :
sig
type key
val key_of_first_insns :
('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
len:int -> Bap.Std.Disasm_expert.Basic.Trie.key option
module Normalized :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t ->
key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp :
'a Regular.Std.printer -> 'a t Regular.Std.printer
end
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
val available_backends : unit -> string list
end
module Linear :
sig
type t = (Bap.Std.mem * Bap.Std.insn option) list
val sweep :
?backend:string ->
Bap.Std.arch ->
Bap.Std.mem ->
Bap.Std.Disasm_expert.Linear.t Core_kernel.Std.Or_error.t
module With_exn :
sig
val sweep :
?backend:string ->
Bap.Std.arch ->
Bap.Std.mem -> Bap.Std.Disasm_expert.Linear.t
end
end
module Recursive :
sig
type t
type error =
[ `Failed_to_disasm of Bap.Std.mem
| `Failed_to_lift of
Bap.Std.mem * Bap.Std.Disasm_expert.Basic.full_insn *
Core_kernel.Std.Error.t ]
val sexp_of_error : error -> Sexplib.Sexp.t
val run :
?backend:string ->
?brancher:Bap.Std.brancher ->
?rooter:Bap.Std.rooter ->
Bap.Std.arch ->
Bap.Std.mem ->
Bap.Std.Disasm_expert.Recursive.t Core_kernel.Std.Or_error.t
val cfg : Bap.Std.Disasm_expert.Recursive.t -> Bap.Std.cfg
val errors :
Bap.Std.Disasm_expert.Recursive.t ->
Bap.Std.Disasm_expert.Recursive.error list
end
end
module Insn :
sig
type t = Bap.Std.insn
val of_basic :
?bil:Bap.Std.bil ->
Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Insn.t
val name : Bap.Std.Insn.t -> string
val asm : Bap.Std.Insn.t -> string
val bil : Bap.Std.Insn.t -> Bap.Std.bil
val ops : Bap.Std.Insn.t -> Bap.Std.op array
type must = Must
type may = May
type 'a property
val new_property : 'a -> string -> 'a Bap.Std.Insn.property
val jump : Bap.Std.Insn.must Bap.Std.Insn.property
val conditional : Bap.Std.Insn.must Bap.Std.Insn.property
val indirect : Bap.Std.Insn.must Bap.Std.Insn.property
val call : Bap.Std.Insn.must Bap.Std.Insn.property
val return : Bap.Std.Insn.must Bap.Std.Insn.property
val affect_control_flow : Bap.Std.Insn.may Bap.Std.Insn.property
val load : Bap.Std.Insn.may Bap.Std.Insn.property
val store : Bap.Std.Insn.may Bap.Std.Insn.property
val is :
Bap.Std.Insn.must Bap.Std.Insn.property -> Bap.Std.Insn.t -> bool
val may :
Bap.Std.Insn.may Bap.Std.Insn.property -> Bap.Std.Insn.t -> bool
val must :
Bap.Std.Insn.must Bap.Std.Insn.property ->
Bap.Std.Insn.t -> Bap.Std.Insn.t
val mustn't :
Bap.Std.Insn.must Bap.Std.Insn.property ->
Bap.Std.Insn.t -> Bap.Std.Insn.t
val should :
Bap.Std.Insn.may Bap.Std.Insn.property ->
Bap.Std.Insn.t -> Bap.Std.Insn.t
val shouldn't :
Bap.Std.Insn.may Bap.Std.Insn.property ->
Bap.Std.Insn.t -> Bap.Std.Insn.t
val pp_adt : Bap.Std.Insn.t Regular.Std.printer
module Trie :
sig
type key
val key_of_insns : Bap.Std.Insn.t list -> Bap.Std.Insn.Trie.key
module Normalized :
sig
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
type key = key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
type 'a t
val bin_t :
'a Core_kernel.Std.Bin_prot.Type_class.t ->
'a t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t :
'a Core_kernel.Std.Bin_prot.Read.reader ->
'a t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'a Core_kernel.Std.Bin_prot.Read.reader ->
(int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t :
'a Core_kernel.Std.Bin_prot.Type_class.reader ->
'a t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t :
'a Core_kernel.Std.Bin_prot.Size.sizer ->
'a t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t :
'a Core_kernel.Std.Bin_prot.Write.writer ->
'a t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t :
'a Core_kernel.Std.Bin_prot.Type_class.writer ->
'a t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t :
Core_kernel.Std.Bin_prot.Shape.t ->
Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change : 'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val walk :
'a t -> key -> init:'b -> f:('b -> 'a option -> 'b) -> 'b
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a Regular.Std.printer -> 'a t Regular.Std.printer
end
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.insn
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Op.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info = string * [ `Ver of string ] * string option
val version : string
val size_in_bytes : ?ver:string -> ?fmt:string -> t -> int
val of_bytes : ?ver:string -> ?fmt:string -> Regular.Std.bytes -> t
val to_bytes : ?ver:string -> ?fmt:string -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:string ->
?fmt:string -> Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:string -> ?fmt:string -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:string -> ?fmt:string -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:string ->
?fmt:string -> Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read : ?ver:string -> ?fmt:string -> string -> t
val load :
?ver:string ->
?fmt:string -> Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:string ->
?fmt:string ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:string ->
?fmt:string ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write : ?ver:string -> ?fmt:string -> string -> t -> unit
val save :
?ver:string ->
?fmt:string -> Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:string ->
?fmt:string ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:string ->
?fmt:string ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show : ?ver:string -> ?fmt:string -> t -> unit
val print :
?ver:string -> ?fmt:string -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:string ->
ver:string -> string -> t Regular.Std.reader -> unit
val add_writer :
?desc:string ->
ver:string -> string -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader : ?ver:string -> string -> unit
val with_reader : ?ver:string -> string -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer : ?ver:string -> string -> unit
val with_writer : ?ver:string -> string -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer : ?ver:string -> string -> unit
val with_printer : ?ver:string -> string -> (unit -> 'a) -> 'a
val find_reader :
?ver:string -> string -> t Regular.Std.reader option
val find_writer :
?ver:string -> string -> t Regular.Std.writer option
end
module Block :
sig
type t = Bap.Std.block
val sexp_of_t : t -> Sexplib.Sexp.t
val create :
Bap.Std.mem ->
(Bap.Std.mem * Bap.Std.insn) list -> Bap.Std.Block.t
val addr : Bap.Std.Block.t -> Bap.Std.addr
val memory : Bap.Std.Block.t -> Bap.Std.mem
val leader : Bap.Std.Block.t -> Bap.Std.insn
val terminator : Bap.Std.Block.t -> Bap.Std.insn
val insns : Bap.Std.Block.t -> (Bap.Std.mem * Bap.Std.insn) list
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Bap.Std.block
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Insn.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
module Graphs :
sig
module Cfg :
sig
type t = cfg
type node = block
type edge
module Node :
sig
type t = node
type graph = cfg
type label
type edge = edge
val create : label -> t
val label : t -> label
val mem : t -> graph -> bool
val succs : t -> graph -> t Regular.Std.seq
val preds : t -> graph -> t Regular.Std.seq
val inputs : t -> graph -> edge Regular.Std.seq
val outputs : t -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val has_edge : t -> t -> graph -> bool
val edge : t -> t -> graph -> edge option
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t ->
node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t -> node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t : node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t : node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(node, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node option) -> t
val of_tree : t -> t
val of_hash_set :
node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (node, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map : t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node -> t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array : node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> node option) -> t
val of_tree : Tree.t -> t
val of_hash_set : node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t : node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t : node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Block.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = node
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> node -> Core_kernel__.Import.bool
val lookup :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> node -> 'a
val enqueue :
'a t -> node -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> node -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val keys : 'a t -> node Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> node * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> node -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> node -> Core_kernel__.Import.unit
val replace :
'a t -> node -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:node -> data:'a -> 'b) -> 'b
end
end
module Edge :
sig
type t = edge
type node = block
type graph = cfg
type label = edge
val create : node -> node -> label -> t
val label : t -> label
val src : t -> node
val dst : t -> node
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t ->
edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set :
edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map : t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array : edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> edge -> Core_kernel__.Import.unit
val replace :
'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
end
val empty : t
val nodes : t -> node Regular.Std.seq
val edges : t -> edge Regular.Std.seq
val is_directed : bool
val number_of_edges : t -> int
val number_of_nodes : t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = cfg
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(cfg, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : cfg -> 'a -> 'a t
val of_alist :
(cfg * 'a) list ->
[ `Duplicate_key of cfg | `Ok of 'a t ]
val of_alist_or_error :
(cfg * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (cfg * 'a) list -> 'a t
val of_alist_multi : (cfg * 'a) list -> 'a list t
val of_alist_fold :
(cfg * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(cfg * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(cfg * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(cfg * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> cfg * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:cfg -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of cfg | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(cfg, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
cfg Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:cfg -> data:'a -> 'a t
val add_multi :
'a list t -> key:cfg -> data:'a -> 'a list t
val remove_multi : 'a list t -> cfg -> 'a list t
val change :
'a t -> cfg -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> cfg -> f:('a option -> 'a) -> 'a t
val find : 'a t -> cfg -> 'a option
val find_exn : 'a t -> cfg -> 'a
val remove : 'a t -> cfg -> 'a t
val mem : 'a t -> cfg -> bool
val iter_keys : 'a t -> f:(cfg -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:cfg -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:cfg ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:cfg -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:cfg -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:cfg -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:cfg ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(cfg -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:cfg -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:cfg -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:cfg -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:cfg -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> cfg list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (cfg * 'a) list
val validate :
name:(cfg -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:cfg ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(cfg, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (cfg * 'a) option
val min_elt_exn : 'a t -> cfg * 'a
val max_elt : 'a t -> (cfg * 'a) option
val max_elt_exn : 'a t -> cfg * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:cfg -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:cfg -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:cfg -> data:'a -> bool) -> int
val split :
'a t -> cfg -> 'a t * (cfg * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:cfg Base__.Maybe_bound.t ->
upper_bound:cfg Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:cfg ->
max:cfg ->
init:'b -> f:(key:cfg -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:cfg -> max:cfg -> (cfg * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> cfg -> (cfg * 'a) option
val nth : 'a t -> int -> (cfg * 'a) option
val nth_exn : 'a t -> int -> cfg * 'a
val rank : 'a t -> cfg -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:cfg ->
?keys_less_or_equal_to:cfg ->
'a t -> (cfg * 'a) Base__.Sequence.t
val obs :
cfg Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
cfg Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> cfg end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(cfg, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : cfg -> 'a -> 'a t
val of_alist :
(cfg * 'a) list ->
[ `Duplicate_key of cfg | `Ok of 'a t ]
val of_alist_or_error :
(cfg * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (cfg * 'a) list -> 'a t
val of_alist_multi : (cfg * 'a) list -> 'a list t
val of_alist_fold :
(cfg * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(cfg * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(cfg * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (cfg * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> cfg * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:cfg -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of cfg | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(cfg, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
cfg Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:cfg -> data:'a -> 'a t
val add_multi :
'a list t -> key:cfg -> data:'a -> 'a list t
val remove_multi : 'a list t -> cfg -> 'a list t
val change :
'a t -> cfg -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> cfg -> f:('a option -> 'a) -> 'a t
val find : 'a t -> cfg -> 'a option
val find_exn : 'a t -> cfg -> 'a
val remove : 'a t -> cfg -> 'a t
val mem : 'a t -> cfg -> bool
val iter_keys : 'a t -> f:(cfg -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:cfg -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:cfg ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:cfg -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:cfg -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:cfg -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:cfg ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(cfg -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:cfg -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:cfg -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:cfg -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:cfg -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> cfg list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (cfg * 'a) list
val validate :
name:(cfg -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:cfg ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(cfg, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (cfg * 'a) option
val min_elt_exn : 'a t -> cfg * 'a
val max_elt : 'a t -> (cfg * 'a) option
val max_elt_exn : 'a t -> cfg * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:cfg -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:cfg -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:cfg -> data:'a -> bool) -> int
val split : 'a t -> cfg -> 'a t * (cfg * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:cfg Base__.Maybe_bound.t ->
upper_bound:cfg Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:cfg ->
max:cfg ->
init:'b -> f:(key:cfg -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:cfg -> max:cfg -> (cfg * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> cfg -> (cfg * 'a) option
val nth : 'a t -> int -> (cfg * 'a) option
val nth_exn : 'a t -> int -> cfg * 'a
val rank : 'a t -> cfg -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:cfg ->
?keys_less_or_equal_to:cfg ->
'a t -> (cfg * 'a) Base__.Sequence.t
val obs :
cfg Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
cfg Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> cfg end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : cfg Bin_prot.Type_class.t
val bin_read_t : cfg Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> cfg)
Bin_prot.Read.reader
val bin_reader_t :
cfg Bin_prot.Type_class.reader
val bin_size_t : cfg Bin_prot.Size.sizer
val bin_write_t : cfg Bin_prot.Write.writer
val bin_writer_t :
cfg Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
cfg -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = cfg
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(cfg, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(cfg -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> cfg -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> cfg -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(cfg -> bool) -> bool
val for_all : t -> f:(cfg -> bool) -> bool
val count : t -> f:(cfg -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(cfg -> 'sum) -> 'sum
val find : t -> f:(cfg -> bool) -> cfg option
val find_map : t -> f:(cfg -> 'a option) -> 'a option
val to_list : t -> cfg list
val to_array : t -> cfg array
val invariants : t -> bool
val mem : t -> cfg -> bool
val add : t -> cfg -> t
val remove : t -> cfg -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (cfg, cfg) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
cfg ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(cfg -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of cfg * cfg
| `Left of cfg
| `Right of cfg ] -> unit) ->
unit
val filter : t -> f:(cfg -> bool) -> t
val partition_tf : t -> f:(cfg -> bool) -> t * t
val elements : t -> cfg list
val min_elt : t -> cfg option
val min_elt_exn : t -> cfg
val max_elt : t -> cfg option
val max_elt_exn : t -> cfg
val choose : t -> cfg option
val choose_exn : t -> cfg
val split : t -> cfg -> t * cfg option * t
val group_by :
t -> equiv:(cfg -> cfg -> bool) -> t list
val find_exn : t -> f:(cfg -> bool) -> cfg
val find_index : t -> int -> cfg option
val nth : t -> int -> cfg option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:cfg ->
?less_or_equal_to:cfg -> t -> cfg Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:cfg ->
?less_or_equal_to:cfg ->
t ->
t ->
(cfg, cfg)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(cfg -> 'data) ->
(cfg, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
cfg Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
cfg Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : cfg -> t
val union_list : t list -> t
val of_list : cfg list -> t
val of_array : cfg array -> t
val of_sorted_array : cfg array -> t Base__.Or_error.t
val of_sorted_array_unchecked : cfg array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> cfg) -> t
val stable_dedup_list : cfg list -> cfg list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> cfg) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> cfg option) -> t
val of_tree : t -> t
val of_hash_set : cfg Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(cfg, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(cfg, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
cfg Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> cfg
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (cfg, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(cfg -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> cfg -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> cfg -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(cfg -> bool) -> bool
val for_all : t -> f:(cfg -> bool) -> bool
val count : t -> f:(cfg -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(cfg -> 'sum) -> 'sum
val find : t -> f:(cfg -> bool) -> cfg option
val find_map : t -> f:(cfg -> 'a option) -> 'a option
val to_list : t -> cfg list
val to_array : t -> cfg array
val invariants : t -> bool
val mem : t -> cfg -> bool
val add : t -> cfg -> t
val remove : t -> cfg -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (cfg, cfg) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
cfg ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(cfg -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of cfg * cfg | `Left of cfg | `Right of cfg ] ->
unit) ->
unit
val filter : t -> f:(cfg -> bool) -> t
val partition_tf : t -> f:(cfg -> bool) -> t * t
val elements : t -> cfg list
val min_elt : t -> cfg option
val min_elt_exn : t -> cfg
val max_elt : t -> cfg option
val max_elt_exn : t -> cfg
val choose : t -> cfg option
val choose_exn : t -> cfg
val split : t -> cfg -> t * cfg option * t
val group_by : t -> equiv:(cfg -> cfg -> bool) -> t list
val find_exn : t -> f:(cfg -> bool) -> cfg
val find_index : t -> int -> cfg option
val nth : t -> int -> cfg option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:cfg ->
?less_or_equal_to:cfg -> t -> cfg Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:cfg ->
?less_or_equal_to:cfg ->
t ->
t ->
(cfg, cfg)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(cfg -> 'data) ->
(cfg, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
cfg Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
cfg Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : cfg -> t
val union_list : t list -> t
val of_list : cfg list -> t
val of_array : cfg array -> t
val of_sorted_array : cfg array -> t Base__.Or_error.t
val of_sorted_array_unchecked : cfg array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> cfg) -> t
val stable_dedup_list : cfg list -> cfg list
val map : ('a, 'b) Base.Set.t -> f:('a -> cfg) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> cfg option) -> t
val of_tree : Tree.t -> t
val of_hash_set : cfg Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(cfg, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(cfg, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
cfg Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> cfg end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : cfg Bin_prot.Type_class.t
val bin_read_t : cfg Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> cfg)
Bin_prot.Read.reader
val bin_reader_t :
cfg Bin_prot.Type_class.reader
val bin_size_t : cfg Bin_prot.Size.sizer
val bin_write_t : cfg Bin_prot.Write.writer
val bin_writer_t :
cfg Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
cfg -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = cfg
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> cfg -> Core_kernel__.Import.bool
val lookup : 'a t -> cfg -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> cfg -> 'a
val enqueue :
'a t -> cfg -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> cfg -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> cfg -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> cfg -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (cfg * 'a) Core_kernel__.Import.option
val keys : 'a t -> cfg Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (cfg * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> cfg * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> cfg -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> cfg -> Core_kernel__.Import.unit
val replace : 'a t -> cfg -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> cfg -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:cfg -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:cfg -> data:'a -> 'b) -> 'b
end
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
module Callgraph :
sig
type t
type node = tid
type edge
module Node :
sig
type t = node
type graph = t
type label = t
type edge = edge
val create : label -> label
val label : label -> label
val mem : label -> graph -> bool
val succs : label -> graph -> label Regular.Std.seq
val preds : label -> graph -> label Regular.Std.seq
val inputs : label -> graph -> edge Regular.Std.seq
val outputs : label -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> label -> graph -> int
val insert : label -> graph -> graph
val update : label -> label -> graph -> graph
val remove : label -> graph -> graph
val has_edge : label -> label -> graph -> bool
val edge : label -> label -> graph -> edge option
val ( >= ) : label -> label -> bool
val ( <= ) : label -> label -> bool
val ( = ) : label -> label -> bool
val ( > ) : label -> label -> bool
val ( < ) : label -> label -> bool
val ( <> ) : label -> label -> bool
val equal : label -> label -> bool
val min : label -> label -> label
val max : label -> label -> label
val ascending : label -> label -> int
val descending : label -> label -> int
val between : label -> low:label -> high:label -> bool
val clamp_exn : label -> min:label -> max:label -> label
val clamp :
label ->
min:label -> max:label -> label Base__.Or_error.t
type comparator_witness
val comparator :
(label, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:label Base__.Maybe_bound.t ->
label Base__.Validate.check
val validate_ubound :
max:label Base__.Maybe_bound.t ->
label Base__.Validate.check
val validate_bound :
min:label Base__.Maybe_bound.t ->
max:label Base__.Maybe_bound.t ->
label Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : label -> label -> bool
val ( <= ) : label -> label -> bool
val ( = ) : label -> label -> bool
val ( > ) : label -> label -> bool
val ( < ) : label -> label -> bool
val ( <> ) : label -> label -> bool
val equal : label -> label -> bool
val compare : label -> label -> int
val min : label -> label -> label
val max : label -> label -> label
end
module Map :
sig
module Key :
sig
type t = label
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(label, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : label -> 'a -> 'a t
val of_alist :
(label * 'a) list ->
[ `Duplicate_key of label | `Ok of 'a t ]
val of_alist_or_error :
(label * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (label * 'a) list -> 'a t
val of_alist_multi : (label * 'a) list -> 'a list t
val of_alist_fold :
(label * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(label * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(label * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(label * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:label -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of label | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:label -> data:'a -> 'a t
val add_multi :
'a list t -> key:label -> data:'a -> 'a list t
val remove_multi : 'a list t -> label -> 'a list t
val change :
'a t ->
label -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> label -> f:('a option -> 'a) -> 'a t
val find : 'a t -> label -> 'a option
val find_exn : 'a t -> label -> 'a
val remove : 'a t -> label -> 'a t
val mem : 'a t -> label -> bool
val iter_keys : 'a t -> f:(label -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:label -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:label -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(label -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:label -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:label -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:label ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:label -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> label list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (label * 'a) list
val validate :
name:(label -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:label ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(label, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (label * 'a) option
val min_elt_exn : 'a t -> label * 'a
val max_elt : 'a t -> (label * 'a) option
val max_elt_exn : 'a t -> label * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:label -> data:'a -> bool) -> int
val split :
'a t ->
label -> 'a t * (label * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:label Base__.Maybe_bound.t ->
upper_bound:label Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:label ->
max:label ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:label -> max:label -> (label * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> label -> (label * 'a) option
val nth : 'a t -> int -> (label * 'a) option
val nth_exn : 'a t -> int -> label * 'a
val rank : 'a t -> label -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:label ->
?keys_less_or_equal_to:label ->
'a t -> (label * 'a) Base__.Sequence.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> label
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(label, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : label -> 'a -> 'a t
val of_alist :
(label * 'a) list ->
[ `Duplicate_key of label | `Ok of 'a t ]
val of_alist_or_error :
(label * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (label * 'a) list -> 'a t
val of_alist_multi : (label * 'a) list -> 'a list t
val of_alist_fold :
(label * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(label * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(label * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(label * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:label -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of label | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:label -> data:'a -> 'a t
val add_multi :
'a list t -> key:label -> data:'a -> 'a list t
val remove_multi : 'a list t -> label -> 'a list t
val change :
'a t -> label -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> label -> f:('a option -> 'a) -> 'a t
val find : 'a t -> label -> 'a option
val find_exn : 'a t -> label -> 'a
val remove : 'a t -> label -> 'a t
val mem : 'a t -> label -> bool
val iter_keys : 'a t -> f:(label -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:label -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:label -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(label -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:label -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:label -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:label ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:label -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> label list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (label * 'a) list
val validate :
name:(label -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:label ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(label, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (label * 'a) option
val min_elt_exn : 'a t -> label * 'a
val max_elt : 'a t -> (label * 'a) option
val max_elt_exn : 'a t -> label * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:label -> data:'a -> bool) -> int
val split :
'a t -> label -> 'a t * (label * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:label Base__.Maybe_bound.t ->
upper_bound:label Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:label ->
max:label ->
init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:label -> max:label -> (label * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> label -> (label * 'a) option
val nth : 'a t -> int -> (label * 'a) option
val nth_exn : 'a t -> int -> label * 'a
val rank : 'a t -> label -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:label ->
?keys_less_or_equal_to:label ->
'a t -> (label * 'a) Base__.Sequence.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> label
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : label Bin_prot.Type_class.t
val bin_read_t :
label Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> label)
Bin_prot.Read.reader
val bin_reader_t :
label Bin_prot.Type_class.reader
val bin_size_t : label Bin_prot.Size.sizer
val bin_write_t :
label Bin_prot.Write.writer
val bin_writer_t :
label Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
label -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = label
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(label, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(label -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> label -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
label -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(label -> bool) -> bool
val for_all : t -> f:(label -> bool) -> bool
val count : t -> f:(label -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(label -> 'sum) -> 'sum
val find : t -> f:(label -> bool) -> label option
val find_map :
t -> f:(label -> 'a option) -> 'a option
val to_list : t -> label list
val to_array : t -> label array
val invariants : t -> bool
val mem : t -> label -> bool
val add : t -> label -> t
val remove : t -> label -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(label, label) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
label ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(label -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of label * label
| `Left of label
| `Right of label ] -> unit) ->
unit
val filter : t -> f:(label -> bool) -> t
val partition_tf : t -> f:(label -> bool) -> t * t
val elements : t -> label list
val min_elt : t -> label option
val min_elt_exn : t -> label
val max_elt : t -> label option
val max_elt_exn : t -> label
val choose : t -> label option
val choose_exn : t -> label
val split : t -> label -> t * label option * t
val group_by :
t -> equiv:(label -> label -> bool) -> t list
val find_exn : t -> f:(label -> bool) -> label
val find_index : t -> int -> label option
val nth : t -> int -> label option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t -> label Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t ->
t ->
(label, label)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(label -> 'data) ->
(label, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : label -> t
val union_list : t list -> t
val of_list : label list -> t
val of_array : label array -> t
val of_sorted_array :
label array -> t Base__.Or_error.t
val of_sorted_array_unchecked : label array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label) -> t
val stable_dedup_list : label list -> label list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> label) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> label option) -> t
val of_tree : t -> t
val of_hash_set :
label Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(label, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(label, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> label
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (label, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(label -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> label -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(label -> bool) -> bool
val for_all : t -> f:(label -> bool) -> bool
val count : t -> f:(label -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(label -> 'sum) -> 'sum
val find : t -> f:(label -> bool) -> label option
val find_map : t -> f:(label -> 'a option) -> 'a option
val to_list : t -> label list
val to_array : t -> label array
val invariants : t -> bool
val mem : t -> label -> bool
val add : t -> label -> t
val remove : t -> label -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (label, label) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
label ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(label -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of label * label
| `Left of label
| `Right of label ] -> unit) ->
unit
val filter : t -> f:(label -> bool) -> t
val partition_tf : t -> f:(label -> bool) -> t * t
val elements : t -> label list
val min_elt : t -> label option
val min_elt_exn : t -> label
val max_elt : t -> label option
val max_elt_exn : t -> label
val choose : t -> label option
val choose_exn : t -> label
val split : t -> label -> t * label option * t
val group_by :
t -> equiv:(label -> label -> bool) -> t list
val find_exn : t -> f:(label -> bool) -> label
val find_index : t -> int -> label option
val nth : t -> int -> label option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t -> label Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t ->
t ->
(label, label)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(label -> 'data) ->
(label, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : label -> t
val union_list : t list -> t
val of_list : label list -> t
val of_array : label array -> t
val of_sorted_array :
label array -> t Base__.Or_error.t
val of_sorted_array_unchecked : label array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label) -> t
val stable_dedup_list : label list -> label list
val map : ('a, 'b) Base.Set.t -> f:('a -> label) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> label option) -> t
val of_tree : Tree.t -> t
val of_hash_set : label Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(label, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(label, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> label
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : label Bin_prot.Type_class.t
val bin_read_t :
label Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> label)
Bin_prot.Read.reader
val bin_reader_t :
label Bin_prot.Type_class.reader
val bin_size_t : label Bin_prot.Size.sizer
val bin_write_t :
label Bin_prot.Write.writer
val bin_writer_t :
label Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
label -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : label -> Core_kernel__.Import.int
val compare : label -> label -> Core_kernel__.Import.int
val hashable :
label Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = label
type ('a, 'b) hashtbl = ('a, 'b) Cfg.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = label
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = label
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> label -> Core_kernel__.Import.bool
val lookup :
'a t -> label -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> label -> 'a
val enqueue :
'a t -> label -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> label -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> label -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> label -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (label * 'a) Core_kernel__.Import.option
val keys : 'a t -> label Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (label * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> label * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> label -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> label -> Core_kernel__.Import.unit
val replace :
'a t -> label -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> label -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:label -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:label -> data:'a -> 'b) -> 'b
end
end
module Edge :
sig
type t = edge
type node = tid
type graph = Node.graph
type label = jmp term list
val create : node -> node -> label -> t
val label : t -> label
val src : t -> node
val dst : t -> node
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t ->
edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set :
edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map : t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array : edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> edge -> Core_kernel__.Import.unit
val replace :
'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
end
val empty : t
val nodes : t -> node Regular.Std.seq
val edges : t -> edge Regular.Std.seq
val is_directed : bool
val number_of_edges : t -> int
val number_of_nodes : t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
module Ir :
sig
type t
type edge
type node
module Edge :
sig
type t = edge
type node = node
type graph = t
type label
val create : node -> node -> label -> t
val label : t -> label
val src : t -> node
val dst : t -> node
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t ->
edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set :
edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map : t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array : edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Callgraph.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> edge -> Core_kernel__.Import.unit
val replace :
'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
val jmps :
[ `after | `before ] ->
Bap.Std.Graphs.Ir.t ->
graph -> Bap.Std.jmp Bap.Std.term Bap.Std.seq
val edges :
[ `after | `before ] ->
Bap.Std.Graphs.Ir.t ->
graph -> Bap.Std.Graphs.Ir.t Bap.Std.seq
val jmp : Bap.Std.Graphs.Ir.t -> Bap.Std.jmp Bap.Std.term
val tid : Bap.Std.Graphs.Ir.t -> Bap.Std.tid
val cond : Bap.Std.Graphs.Ir.t -> graph -> Bap.Std.exp
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
module Node :
sig
type t = node
type graph = Edge.graph
type label = blk term
type edge = Edge.t
val create : label -> t
val label : t -> label
val mem : t -> graph -> bool
val succs : t -> graph -> t Regular.Std.seq
val preds : t -> graph -> t Regular.Std.seq
val inputs : t -> graph -> edge Regular.Std.seq
val outputs : t -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val has_edge : t -> t -> graph -> bool
val edge : t -> t -> graph -> edge option
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t ->
node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t -> node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t : node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t : node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(node, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node option) -> t
val of_tree : t -> t
val of_hash_set :
node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (node, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map : t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node -> t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array : node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> node option) -> t
val of_tree : Tree.t -> t
val of_hash_set : node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t : node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t : node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = node
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> node -> Core_kernel__.Import.bool
val lookup :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> node -> 'a
val enqueue :
'a t -> node -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> node -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val keys : 'a t -> node Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> node * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> node -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> node -> Core_kernel__.Import.unit
val replace :
'a t -> node -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:node -> data:'a -> 'b) -> 'b
end
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
val empty : t
val nodes : t -> node Regular.Std.seq
val edges : t -> edge Regular.Std.seq
val is_directed : bool
val number_of_edges : t -> int
val number_of_nodes : t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Node.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Node.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
module Tid :
sig
type t
type node = tid
type edge
module Node :
sig
type t = node
type graph = t
type label = t
type edge = edge
val create : label -> label
val label : label -> label
val mem : label -> graph -> bool
val succs : label -> graph -> label Regular.Std.seq
val preds : label -> graph -> label Regular.Std.seq
val inputs : label -> graph -> edge Regular.Std.seq
val outputs : label -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> label -> graph -> int
val insert : label -> graph -> graph
val update : label -> label -> graph -> graph
val remove : label -> graph -> graph
val has_edge : label -> label -> graph -> bool
val edge : label -> label -> graph -> edge option
val ( >= ) : label -> label -> bool
val ( <= ) : label -> label -> bool
val ( = ) : label -> label -> bool
val ( > ) : label -> label -> bool
val ( < ) : label -> label -> bool
val ( <> ) : label -> label -> bool
val equal : label -> label -> bool
val min : label -> label -> label
val max : label -> label -> label
val ascending : label -> label -> int
val descending : label -> label -> int
val between : label -> low:label -> high:label -> bool
val clamp_exn : label -> min:label -> max:label -> label
val clamp :
label ->
min:label -> max:label -> label Base__.Or_error.t
type comparator_witness
val comparator :
(label, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:label Base__.Maybe_bound.t ->
label Base__.Validate.check
val validate_ubound :
max:label Base__.Maybe_bound.t ->
label Base__.Validate.check
val validate_bound :
min:label Base__.Maybe_bound.t ->
max:label Base__.Maybe_bound.t ->
label Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : label -> label -> bool
val ( <= ) : label -> label -> bool
val ( = ) : label -> label -> bool
val ( > ) : label -> label -> bool
val ( < ) : label -> label -> bool
val ( <> ) : label -> label -> bool
val equal : label -> label -> bool
val compare : label -> label -> int
val min : label -> label -> label
val max : label -> label -> label
end
module Map :
sig
module Key :
sig
type t = label
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(label, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : label -> 'a -> 'a t
val of_alist :
(label * 'a) list ->
[ `Duplicate_key of label | `Ok of 'a t ]
val of_alist_or_error :
(label * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (label * 'a) list -> 'a t
val of_alist_multi : (label * 'a) list -> 'a list t
val of_alist_fold :
(label * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(label * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(label * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(label * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:label -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of label | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:label -> data:'a -> 'a t
val add_multi :
'a list t -> key:label -> data:'a -> 'a list t
val remove_multi : 'a list t -> label -> 'a list t
val change :
'a t ->
label -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> label -> f:('a option -> 'a) -> 'a t
val find : 'a t -> label -> 'a option
val find_exn : 'a t -> label -> 'a
val remove : 'a t -> label -> 'a t
val mem : 'a t -> label -> bool
val iter_keys : 'a t -> f:(label -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:label -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:label -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(label -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:label -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:label -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:label ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:label -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> label list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (label * 'a) list
val validate :
name:(label -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:label ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(label, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (label * 'a) option
val min_elt_exn : 'a t -> label * 'a
val max_elt : 'a t -> (label * 'a) option
val max_elt_exn : 'a t -> label * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:label -> data:'a -> bool) -> int
val split :
'a t ->
label -> 'a t * (label * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:label Base__.Maybe_bound.t ->
upper_bound:label Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:label ->
max:label ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:label -> max:label -> (label * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> label -> (label * 'a) option
val nth : 'a t -> int -> (label * 'a) option
val nth_exn : 'a t -> int -> label * 'a
val rank : 'a t -> label -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:label ->
?keys_less_or_equal_to:label ->
'a t -> (label * 'a) Base__.Sequence.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> label
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(label, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : label -> 'a -> 'a t
val of_alist :
(label * 'a) list ->
[ `Duplicate_key of label | `Ok of 'a t ]
val of_alist_or_error :
(label * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (label * 'a) list -> 'a t
val of_alist_multi : (label * 'a) list -> 'a list t
val of_alist_fold :
(label * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(label * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(label * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(label * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:label -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of label | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:label -> data:'a -> 'a t
val add_multi :
'a list t -> key:label -> data:'a -> 'a list t
val remove_multi : 'a list t -> label -> 'a list t
val change :
'a t -> label -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> label -> f:('a option -> 'a) -> 'a t
val find : 'a t -> label -> 'a option
val find_exn : 'a t -> label -> 'a
val remove : 'a t -> label -> 'a t
val mem : 'a t -> label -> bool
val iter_keys : 'a t -> f:(label -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:label -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:label -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(label -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:label -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:label -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:label ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:label -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> label list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (label * 'a) list
val validate :
name:(label -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:label ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(label, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (label * 'a) option
val min_elt_exn : 'a t -> label * 'a
val max_elt : 'a t -> (label * 'a) option
val max_elt_exn : 'a t -> label * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:label -> data:'a -> bool) -> int
val split :
'a t -> label -> 'a t * (label * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:label Base__.Maybe_bound.t ->
upper_bound:label Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:label ->
max:label ->
init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:label -> max:label -> (label * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> label -> (label * 'a) option
val nth : 'a t -> int -> (label * 'a) option
val nth_exn : 'a t -> int -> label * 'a
val rank : 'a t -> label -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:label ->
?keys_less_or_equal_to:label ->
'a t -> (label * 'a) Base__.Sequence.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> label
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : label Bin_prot.Type_class.t
val bin_read_t :
label Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> label)
Bin_prot.Read.reader
val bin_reader_t :
label Bin_prot.Type_class.reader
val bin_size_t : label Bin_prot.Size.sizer
val bin_write_t :
label Bin_prot.Write.writer
val bin_writer_t :
label Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
label -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = label
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(label, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(label -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> label -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
label -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(label -> bool) -> bool
val for_all : t -> f:(label -> bool) -> bool
val count : t -> f:(label -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(label -> 'sum) -> 'sum
val find : t -> f:(label -> bool) -> label option
val find_map :
t -> f:(label -> 'a option) -> 'a option
val to_list : t -> label list
val to_array : t -> label array
val invariants : t -> bool
val mem : t -> label -> bool
val add : t -> label -> t
val remove : t -> label -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(label, label) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
label ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(label -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of label * label
| `Left of label
| `Right of label ] -> unit) ->
unit
val filter : t -> f:(label -> bool) -> t
val partition_tf : t -> f:(label -> bool) -> t * t
val elements : t -> label list
val min_elt : t -> label option
val min_elt_exn : t -> label
val max_elt : t -> label option
val max_elt_exn : t -> label
val choose : t -> label option
val choose_exn : t -> label
val split : t -> label -> t * label option * t
val group_by :
t -> equiv:(label -> label -> bool) -> t list
val find_exn : t -> f:(label -> bool) -> label
val find_index : t -> int -> label option
val nth : t -> int -> label option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t -> label Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t ->
t ->
(label, label)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(label -> 'data) ->
(label, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : label -> t
val union_list : t list -> t
val of_list : label list -> t
val of_array : label array -> t
val of_sorted_array :
label array -> t Base__.Or_error.t
val of_sorted_array_unchecked : label array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label) -> t
val stable_dedup_list : label list -> label list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> label) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> label option) -> t
val of_tree : t -> t
val of_hash_set :
label Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(label, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(label, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> label
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (label, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(label -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> label -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(label -> bool) -> bool
val for_all : t -> f:(label -> bool) -> bool
val count : t -> f:(label -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(label -> 'sum) -> 'sum
val find : t -> f:(label -> bool) -> label option
val find_map : t -> f:(label -> 'a option) -> 'a option
val to_list : t -> label list
val to_array : t -> label array
val invariants : t -> bool
val mem : t -> label -> bool
val add : t -> label -> t
val remove : t -> label -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (label, label) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
label ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(label -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of label * label
| `Left of label
| `Right of label ] -> unit) ->
unit
val filter : t -> f:(label -> bool) -> t
val partition_tf : t -> f:(label -> bool) -> t * t
val elements : t -> label list
val min_elt : t -> label option
val min_elt_exn : t -> label
val max_elt : t -> label option
val max_elt_exn : t -> label
val choose : t -> label option
val choose_exn : t -> label
val split : t -> label -> t * label option * t
val group_by :
t -> equiv:(label -> label -> bool) -> t list
val find_exn : t -> f:(label -> bool) -> label
val find_index : t -> int -> label option
val nth : t -> int -> label option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t -> label Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t ->
t ->
(label, label)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(label -> 'data) ->
(label, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : label -> t
val union_list : t list -> t
val of_list : label list -> t
val of_array : label array -> t
val of_sorted_array :
label array -> t Base__.Or_error.t
val of_sorted_array_unchecked : label array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label) -> t
val stable_dedup_list : label list -> label list
val map : ('a, 'b) Base.Set.t -> f:('a -> label) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> label option) -> t
val of_tree : Tree.t -> t
val of_hash_set : label Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(label, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(label, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> label
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : label Bin_prot.Type_class.t
val bin_read_t :
label Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> label)
Bin_prot.Read.reader
val bin_reader_t :
label Bin_prot.Type_class.reader
val bin_size_t : label Bin_prot.Size.sizer
val bin_write_t :
label Bin_prot.Write.writer
val bin_writer_t :
label Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
label -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : label -> Core_kernel__.Import.int
val compare : label -> label -> Core_kernel__.Import.int
val hashable :
label Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = label
type ('a, 'b) hashtbl = ('a, 'b) Ir.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = label
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = label
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> label -> Core_kernel__.Import.bool
val lookup :
'a t -> label -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> label -> 'a
val enqueue :
'a t -> label -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> label -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> label -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> label -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (label * 'a) Core_kernel__.Import.option
val keys : 'a t -> label Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (label * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> label * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> label -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> label -> Core_kernel__.Import.unit
val replace :
'a t -> label -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> label -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:label -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:label -> data:'a -> 'b) -> 'b
end
end
module Edge :
sig
type t = edge
type node = tid
type graph = Node.graph
type label = node
val create : label -> label -> label -> t
val label : t -> label
val src : t -> label
val dst : t -> label
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t ->
edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set :
edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map : t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array : edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> edge -> Core_kernel__.Import.unit
val replace :
'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
end
val empty : t
val nodes : t -> node Regular.Std.seq
val edges : t -> edge Regular.Std.seq
val is_directed : bool
val number_of_edges : t -> int
val number_of_nodes : t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
end
module Disasm :
sig
type t = Bap.Std.disasm
val create : Bap.Std.cfg -> Bap.Std.Disasm.t
val of_mem :
?backend:string ->
?brancher:Bap.Std.brancher ->
?rooter:Bap.Std.rooter ->
Bap.Std.arch ->
Bap.Std.mem -> Bap.Std.Disasm.t Core_kernel.Std.Or_error.t
val of_image :
?backend:string ->
?brancher:Bap.Std.brancher ->
?rooter:Bap.Std.rooter ->
Bap.Std.image -> Bap.Std.Disasm.t Core_kernel.Std.Or_error.t
val of_file :
?backend:string ->
?brancher:Bap.Std.brancher ->
?rooter:Bap.Std.rooter ->
?loader:string ->
string -> Bap.Std.Disasm.t Core_kernel.Std.Or_error.t
module With_exn :
sig
val of_mem :
?backend:string ->
?brancher:Bap.Std.brancher ->
?rooter:Bap.Std.rooter ->
Bap.Std.arch -> Bap.Std.mem -> Bap.Std.Disasm.t
val of_image :
?backend:string ->
?brancher:Bap.Std.brancher ->
?rooter:Bap.Std.rooter -> Bap.Std.image -> Bap.Std.Disasm.t
val of_file :
?backend:string ->
?brancher:Bap.Std.brancher ->
?rooter:Bap.Std.rooter ->
?loader:string -> string -> Bap.Std.Disasm.t
end
val merge :
Bap.Std.Disasm.t -> Bap.Std.Disasm.t -> Bap.Std.Disasm.t
val insns :
Bap.Std.Disasm.t -> (Bap.Std.mem * Bap.Std.insn) Bap.Std.seq
val cfg : Bap.Std.Disasm.t -> Bap.Std.cfg
val insn : Bap.Std.insn Bap.Std.tag
end
type symtab
module Symtab :
sig
type t = Bap.Std.symtab
val sexp_of_t : t -> Sexplib.Sexp.t
type fn = string * Bap.Std.block * Bap.Std.cfg
val sexp_of_fn : fn -> Sexplib.Sexp.t
val empty : Bap.Std.Symtab.t
val add_symbol :
Bap.Std.Symtab.t -> Bap.Std.Symtab.fn -> Bap.Std.Symtab.t
val remove :
Bap.Std.Symtab.t -> Bap.Std.Symtab.fn -> Bap.Std.Symtab.t
val find_by_name :
Bap.Std.Symtab.t -> string -> Bap.Std.Symtab.fn option
val find_by_start :
Bap.Std.Symtab.t -> Bap.Std.addr -> Bap.Std.Symtab.fn option
val owners :
Bap.Std.Symtab.t -> Bap.Std.addr -> Bap.Std.Symtab.fn list
val dominators :
Bap.Std.Symtab.t -> Bap.Std.mem -> Bap.Std.Symtab.fn list
val intersecting :
Bap.Std.Symtab.t -> Bap.Std.mem -> Bap.Std.Symtab.fn list
val to_sequence : Bap.Std.Symtab.t -> Bap.Std.Symtab.fn Bap.Std.seq
val span : Bap.Std.Symtab.fn -> unit Bap.Std.memmap
end
type lifter =
Bap.Std.mem ->
Bap.Std.Disasm_expert.Basic.full_insn ->
Bap.Std.bil Core_kernel.Std.Or_error.t
module type CPU =
sig
val gpr : Bap.Std.Var.Set.t
val mem : Bap.Std.var
val sp : Bap.Std.var
val zf : Bap.Std.var
val cf : Bap.Std.var
val vf : Bap.Std.var
val nf : Bap.Std.var
val is_reg : Bap.Std.var -> bool
val is_flag : Bap.Std.var -> bool
val is_sp : Bap.Std.var -> bool
val is_bp : Bap.Std.var -> bool
val is_zf : Bap.Std.var -> bool
val is_cf : Bap.Std.var -> bool
val is_vf : Bap.Std.var -> bool
val is_nf : Bap.Std.var -> bool
val is_mem : Bap.Std.var -> bool
end
module type Target = sig module CPU : CPU val lift : Bap.Std.lifter end
val target_of_arch : Bap.Std.arch -> (module Bap.Std.Target)
val register_target : Bap.Std.arch -> (module Bap.Std.Target) -> unit
module Tid :
sig
type t = Bap.Std.tid
val create : unit -> Bap.Std.Tid.t
val set_name : Bap.Std.tid -> string -> unit
val name : Bap.Std.tid -> string
val from_string : string -> Bap.Std.tid Core_kernel.Std.Or_error.t
val from_string_exn : string -> Bap.Std.tid
val ( !! ) : string -> Bap.Std.tid
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.tid
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Block.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Term :
sig
type 'a t = 'a Bap.Std.term
val clone : 'a Bap.Std.Term.t -> 'a Bap.Std.Term.t
val same : 'a Bap.Std.Term.t -> 'a Bap.Std.Term.t -> bool
val name : 'a Bap.Std.Term.t -> string
val tid : 'a Bap.Std.Term.t -> Bap.Std.tid
val length : ('a, 'b) Bap.Std.cls -> 'a Bap.Std.Term.t -> int
val find :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t option
val find_exn :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t
val update :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t -> 'a Bap.Std.Term.t
val remove :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'a Bap.Std.Term.t
val change :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t ->
Bap.Std.tid ->
('b Bap.Std.Term.t option -> 'b Bap.Std.Term.t option) ->
'a Bap.Std.Term.t
val enum :
?rev:bool ->
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t Bap.Std.seq
val to_sequence :
?rev:bool ->
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t Bap.Std.seq
val map :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t ->
f:('b Bap.Std.Term.t -> 'b Bap.Std.Term.t) -> 'a Bap.Std.Term.t
val filter_map :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t ->
f:('b Bap.Std.Term.t -> 'b Bap.Std.Term.t option) ->
'a Bap.Std.Term.t
val concat_map :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t ->
f:('b Bap.Std.Term.t -> 'b Bap.Std.Term.t list) ->
'a Bap.Std.Term.t
val filter :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t ->
f:('b Bap.Std.Term.t -> bool) -> 'a Bap.Std.Term.t
val first :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t option
val last :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t option
val next :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t option
val prev :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t option
val after :
('a, 'b) Bap.Std.cls ->
?rev:bool ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t Bap.Std.seq
val before :
('a, 'b) Bap.Std.cls ->
?rev:bool ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t Bap.Std.seq
val append :
('a, 'b) Bap.Std.cls ->
?after:Bap.Std.tid ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t -> 'a Bap.Std.Term.t
val prepend :
('a, 'b) Bap.Std.cls ->
?before:Bap.Std.tid ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t -> 'a Bap.Std.Term.t
val nth :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> int -> 'b Bap.Std.Term.t option
val nth_exn :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> int -> 'b Bap.Std.Term.t
val set_attr :
'a Bap.Std.Term.t -> 'b Bap.Std.tag -> 'b -> 'a Bap.Std.Term.t
val attrs : 'a Bap.Std.Term.t -> Bap.Std.Dict.t
val with_attrs :
'a Bap.Std.Term.t -> Bap.Std.Dict.t -> 'a Bap.Std.Term.t
val get_attr : 'a Bap.Std.Term.t -> 'b Bap.Std.tag -> 'b option
val has_attr : 'a Bap.Std.Term.t -> 'b Bap.Std.tag -> bool
val del_attr :
'a Bap.Std.Term.t -> 'b Bap.Std.tag -> 'a Bap.Std.Term.t
val origin : Bap.Std.tid Bap.Std.tag
val synthetic : unit Bap.Std.tag
val live : unit Bap.Std.tag
val dead : unit Bap.Std.tag
val visited : unit Bap.Std.tag
val precondition : Bap.Std.exp Bap.Std.tag
val invariant : Bap.Std.exp Bap.Std.tag
val postcondition : Bap.Std.exp Bap.Std.tag
class mapper :
object
val exps_stack : exp list
val under_condition : bool
method map_arg :
Bap.Std.arg Bap.Std.term -> Bap.Std.arg Bap.Std.term
method map_binop : binop -> Exp.t -> Exp.t -> Exp.t
method map_blk :
Bap.Std.blk Bap.Std.term -> Bap.Std.blk Bap.Std.term
method map_cast : cast -> int -> Exp.t -> Exp.t
method map_concat : Exp.t -> Exp.t -> Exp.t
method map_def :
Bap.Std.def Bap.Std.term -> Bap.Std.def Bap.Std.term
method map_exp : Exp.t -> Exp.t
method map_extract : hi:int -> lo:int -> Exp.t -> Exp.t
method map_int : word -> Exp.t
method map_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> Exp.t
method map_jmp :
Bap.Std.jmp Bap.Std.term -> Bap.Std.jmp Bap.Std.term
method map_let : var -> exp:Exp.t -> body:Exp.t -> Exp.t
method map_load :
mem:Exp.t -> addr:Exp.t -> endian -> size -> Exp.t
method map_phi :
Bap.Std.phi Bap.Std.term -> Bap.Std.phi Bap.Std.term
method map_store :
mem:Exp.t ->
addr:Exp.t -> exp:Exp.t -> endian -> size -> Exp.t
method map_sub :
Bap.Std.sub Bap.Std.term -> Bap.Std.sub Bap.Std.term
method map_sym : var -> var
method map_term :
('p, 't) Bap.Std.cls -> 't Bap.Std.term -> 't Bap.Std.term
method map_unknown : Trie.String.Suffix.key -> typ -> Exp.t
method map_unop : unop -> Exp.t -> Exp.t
method map_var : var -> Exp.t
method run :
Bap.Std.program Bap.Std.term -> Bap.Std.program Bap.Std.term
end
class ['a] visitor :
object
val exps_stack : exp list
val under_condition : bool
method enter_arg : Bap.Std.arg Bap.Std.term -> 'a -> 'a
method enter_binop : binop -> Exp.t -> Exp.t -> 'a -> 'a
method enter_blk : Bap.Std.blk Bap.Std.term -> 'a -> 'a
method enter_cast : cast -> int -> Exp.t -> 'a -> 'a
method enter_concat : Exp.t -> Exp.t -> 'a -> 'a
method enter_def : Bap.Std.def Bap.Std.term -> 'a -> 'a
method enter_exp : Exp.t -> 'a -> 'a
method enter_extract : hi:int -> lo:int -> Exp.t -> 'a -> 'a
method enter_int : word -> 'a -> 'a
method enter_ite :
cond:Exp.t -> yes:Exp.t -> no:Exp.t -> 'a -> 'a
method enter_jmp : Bap.Std.jmp Bap.Std.term -> 'a -> 'a
method enter_let : var -> exp:Exp.t -> body:Exp.t -> 'a -> 'a
method enter_load :
mem:Exp.t -> addr:Exp.t -> endian -> size -> 'a -> 'a
method enter_phi : Bap.Std.phi Bap.Std.term -> 'a -> 'a
method enter_program : Bap.Std.program Bap.Std.term -> 'a -> 'a
method enter_store :
mem:Exp.t ->
addr:Exp.t -> exp:Exp.t -> endian -> size -> 'a -> 'a
method enter_sub : Bap.Std.sub Bap.Std.term -> 'a -> 'a
method enter_term :
('p, 't) Bap.Std.cls -> 't Bap.Std.term -> 'a -> 'a
method enter_unknown :
Trie.String.Suffix.key -> typ -> 'a -> 'a
method enter_unop : unop -> Exp.t -> 'a -> 'a
method enter_var : var -> 'a -> 'a
method leave_arg : Bap.Std.arg Bap.Std.term -> 'a -> 'a
method leave_binop : binop -> Exp.t -> Exp.t -> 'a -> 'a
method leave_blk : Bap.Std.blk Bap.Std.term -> 'a -> 'a
method leave_cast : cast -> int -> Exp.t -> 'a -> 'a
method leave_concat : Exp.t -> Exp.t -> 'a -> 'a
method leave_def : Bap.Std.def Bap.Std.term -> 'a -> 'a
method leave_exp : Exp.t -> 'a -> 'a
method leave_extract : hi:int -> lo:int -> Exp.t -> 'a -> 'a
method leave_int : word -> 'a -> 'a
method leave_ite :
cond:Exp.t -> yes:Exp.t -> no:Exp.t -> 'a -> 'a
method leave_jmp : Bap.Std.jmp Bap.Std.term -> 'a -> 'a
method leave_let : var -> exp:Exp.t -> body:Exp.t -> 'a -> 'a
method leave_load :
mem:Exp.t -> addr:Exp.t -> endian -> size -> 'a -> 'a
method leave_phi : Bap.Std.phi Bap.Std.term -> 'a -> 'a
method leave_program : Bap.Std.program Bap.Std.term -> 'a -> 'a
method leave_store :
mem:Exp.t ->
addr:Exp.t -> exp:Exp.t -> endian -> size -> 'a -> 'a
method leave_sub : Bap.Std.sub Bap.Std.term -> 'a -> 'a
method leave_term :
('p, 't) Bap.Std.cls -> 't Bap.Std.term -> 'a -> 'a
method leave_unknown :
Trie.String.Suffix.key -> typ -> 'a -> 'a
method leave_unop : unop -> Exp.t -> 'a -> 'a
method leave_var : var -> 'a -> 'a
method run : Bap.Std.program Bap.Std.term -> 'a -> 'a
method visit_arg : Bap.Std.arg Bap.Std.term -> 'a -> 'a
method visit_binop : binop -> Exp.t -> Exp.t -> 'a -> 'a
method visit_blk : Bap.Std.blk Bap.Std.term -> 'a -> 'a
method visit_cast : cast -> int -> Exp.t -> 'a -> 'a
method visit_concat : Exp.t -> Exp.t -> 'a -> 'a
method visit_def : Bap.Std.def Bap.Std.term -> 'a -> 'a
method visit_exp : Exp.t -> 'a -> 'a
method visit_extract : hi:int -> lo:int -> Exp.t -> 'a -> 'a
method visit_int : word -> 'a -> 'a
method visit_ite :
cond:Exp.t -> yes:Exp.t -> no:Exp.t -> 'a -> 'a
method visit_jmp : Bap.Std.jmp Bap.Std.term -> 'a -> 'a
method visit_let : var -> exp:Exp.t -> body:Exp.t -> 'a -> 'a
method visit_load :
mem:Exp.t -> addr:Exp.t -> endian -> size -> 'a -> 'a
method visit_phi : Bap.Std.phi Bap.Std.term -> 'a -> 'a
method visit_store :
mem:Exp.t ->
addr:Exp.t -> exp:Exp.t -> endian -> size -> 'a -> 'a
method visit_sub : Bap.Std.sub Bap.Std.term -> 'a -> 'a
method visit_term :
('p, 't) Bap.Std.cls -> 't Bap.Std.term -> 'a -> 'a
method visit_unknown :
Trie.String.Suffix.key -> typ -> 'a -> 'a
method visit_unop : unop -> Exp.t -> 'a -> 'a
method visit_var : var -> 'a -> 'a
end
val switch :
('p, 't) Bap.Std.cls ->
program:(Bap.Std.program Bap.Std.term -> 'a) ->
sub:(Bap.Std.sub Bap.Std.term -> 'a) ->
arg:(Bap.Std.arg Bap.Std.term -> 'a) ->
blk:(Bap.Std.blk Bap.Std.term -> 'a) ->
phi:(Bap.Std.phi Bap.Std.term -> 'a) ->
def:(Bap.Std.def Bap.Std.term -> 'a) ->
jmp:(Bap.Std.jmp Bap.Std.term -> 'a) -> 't Bap.Std.term -> 'a
val proj :
('p, 't) Bap.Std.cls ->
?program:(Bap.Std.program Bap.Std.term -> 'a option) ->
?sub:(Bap.Std.sub Bap.Std.term -> 'a option) ->
?arg:(Bap.Std.arg Bap.Std.term -> 'a option) ->
?blk:(Bap.Std.blk Bap.Std.term -> 'a option) ->
?phi:(Bap.Std.phi Bap.Std.term -> 'a option) ->
?def:(Bap.Std.def Bap.Std.term -> 'a option) ->
?jmp:(Bap.Std.jmp Bap.Std.term -> 'a option) ->
't Bap.Std.term -> 'a option
val cata :
('p, 't) Bap.Std.cls ->
init:'a ->
?program:(Bap.Std.program Bap.Std.term -> 'a) ->
?sub:(Bap.Std.sub Bap.Std.term -> 'a) ->
?arg:(Bap.Std.arg Bap.Std.term -> 'a) ->
?blk:(Bap.Std.blk Bap.Std.term -> 'a) ->
?phi:(Bap.Std.phi Bap.Std.term -> 'a) ->
?def:(Bap.Std.def Bap.Std.term -> 'a) ->
?jmp:(Bap.Std.jmp Bap.Std.term -> 'a) -> 't Bap.Std.term -> 'a
end
module Program :
sig
type t = Bap.Std.program Bap.Std.term
val create : ?tid:Bap.Std.tid -> unit -> Bap.Std.Program.t
val lift : Bap.Std.symtab -> Bap.Std.program Bap.Std.term
val to_graph : Bap.Std.Program.t -> Bap.Std.Graphs.Callgraph.t
val lookup :
('a, 'b) Bap.Std.cls ->
Bap.Std.Program.t -> Bap.Std.tid -> 'b Bap.Std.term option
val parent :
('a, 'b) Bap.Std.cls ->
Bap.Std.Program.t -> Bap.Std.tid -> 'a Bap.Std.term option
module Builder :
sig
type t
val create :
?tid:Bap.Std.tid ->
?subs:int -> unit -> Bap.Std.Program.Builder.t
val add_sub :
Bap.Std.Program.Builder.t -> Bap.Std.sub Bap.Std.term -> unit
val result :
Bap.Std.Program.Builder.t -> Bap.Std.program Bap.Std.term
end
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Tid.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Sub :
sig
type t = Bap.Std.sub Bap.Std.term
val create :
?tid:Bap.Std.tid -> ?name:string -> unit -> Bap.Std.Sub.t
val lift : Bap.Std.block -> Bap.Std.cfg -> Bap.Std.sub Bap.Std.term
val name : Bap.Std.Sub.t -> string
val with_name : Bap.Std.Sub.t -> string -> Bap.Std.Sub.t
val ssa : Bap.Std.Sub.t -> Bap.Std.Sub.t
val is_ssa : Bap.Std.Sub.t -> bool
val free_vars : Bap.Std.Sub.t -> Bap.Std.Var.Set.t
val to_graph : Bap.Std.Sub.t -> Bap.Std.Graphs.Tid.t
val to_cfg : Bap.Std.Sub.t -> Bap.Std.Graphs.Ir.t
val of_cfg : Bap.Std.Graphs.Ir.t -> Bap.Std.Sub.t
val aliases : string list Bap.Std.tag
val const : unit Bap.Std.tag
val pure : unit Bap.Std.tag
val stub : unit Bap.Std.tag
val extern : unit Bap.Std.tag
val leaf : unit Bap.Std.tag
val malloc : unit Bap.Std.tag
val noreturn : unit Bap.Std.tag
val returns_twice : unit Bap.Std.tag
val nothrow : unit Bap.Std.tag
val entry_point : unit Bap.Std.tag
module Builder :
sig
type t
val create :
?tid:Bap.Std.tid ->
?args:int ->
?blks:int -> ?name:string -> unit -> Bap.Std.Sub.Builder.t
val add_blk :
Bap.Std.Sub.Builder.t -> Bap.Std.blk Bap.Std.term -> unit
val add_arg :
Bap.Std.Sub.Builder.t -> Bap.Std.arg Bap.Std.term -> unit
val result : Bap.Std.Sub.Builder.t -> Bap.Std.sub Bap.Std.term
end
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Program.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Blk :
sig
type t = Bap.Std.blk Bap.Std.term
type elt =
[ `Def of Bap.Std.def Bap.Std.term
| `Jmp of Bap.Std.jmp Bap.Std.term
| `Phi of Bap.Std.phi Bap.Std.term ]
val create : ?tid:Bap.Std.tid -> unit -> Bap.Std.Blk.t
val lift :
Bap.Std.cfg -> Bap.Std.block -> Bap.Std.blk Bap.Std.term list
val from_insn : Bap.Std.insn -> Bap.Std.blk Bap.Std.term list
val split_while :
Bap.Std.Blk.t ->
f:(Bap.Std.def Bap.Std.term -> bool) ->
Bap.Std.Blk.t * Bap.Std.Blk.t
val split_after :
Bap.Std.Blk.t ->
Bap.Std.def Bap.Std.term -> Bap.Std.Blk.t * Bap.Std.Blk.t
val split_before :
Bap.Std.Blk.t ->
Bap.Std.def Bap.Std.term -> Bap.Std.Blk.t * Bap.Std.Blk.t
val split_top : Bap.Std.Blk.t -> Bap.Std.Blk.t * Bap.Std.Blk.t
val split_bot : Bap.Std.Blk.t -> Bap.Std.Blk.t * Bap.Std.Blk.t
val elts :
?rev:bool -> Bap.Std.Blk.t -> Bap.Std.Blk.elt Bap.Std.seq
val map_exp :
?skip:[ `def | `jmp | `phi ] list ->
Bap.Std.Blk.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Blk.t
val map_elts :
?phi:(Bap.Std.phi Bap.Std.term -> Bap.Std.phi Bap.Std.term) ->
?def:(Bap.Std.def Bap.Std.term -> Bap.Std.def Bap.Std.term) ->
?jmp:(Bap.Std.jmp Bap.Std.term -> Bap.Std.jmp Bap.Std.term) ->
Bap.Std.blk Bap.Std.term -> Bap.Std.blk Bap.Std.term
val substitute :
?skip:[ `def | `jmp | `phi ] list ->
Bap.Std.Blk.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Blk.t
val map_lhs :
?skip:[ `def | `phi ] list ->
Bap.Std.Blk.t -> f:(Bap.Std.var -> Bap.Std.var) -> Bap.Std.Blk.t
val find_var :
Bap.Std.Blk.t ->
Bap.Std.var ->
[ `Def of Bap.Std.def Bap.Std.term
| `Phi of Bap.Std.phi Bap.Std.term ] option
val defines_var : Bap.Std.Blk.t -> Bap.Std.var -> bool
val free_vars : Bap.Std.Blk.t -> Bap.Std.Var.Set.t
val uses_var : Bap.Std.Blk.t -> Bap.Std.var -> bool
val occurs :
Bap.Std.Blk.t -> after:Bap.Std.tid -> Bap.Std.tid -> bool
module Builder :
sig
type t
val create :
?tid:Bap.Std.tid ->
?phis:int ->
?defs:int -> ?jmps:int -> unit -> Bap.Std.Blk.Builder.t
val init :
?same_tid:bool ->
?copy_phis:bool ->
?copy_defs:bool ->
?copy_jmps:bool ->
Bap.Std.blk Bap.Std.term -> Bap.Std.Blk.Builder.t
val add_def :
Bap.Std.Blk.Builder.t -> Bap.Std.def Bap.Std.term -> unit
val add_jmp :
Bap.Std.Blk.Builder.t -> Bap.Std.jmp Bap.Std.term -> unit
val add_phi :
Bap.Std.Blk.Builder.t -> Bap.Std.phi Bap.Std.term -> unit
val add_elt : Bap.Std.Blk.Builder.t -> Bap.Std.Blk.elt -> unit
val result : Bap.Std.Blk.Builder.t -> Bap.Std.blk Bap.Std.term
end
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Sub.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Def :
sig
type t = Bap.Std.def Bap.Std.term
val create :
?tid:Bap.Std.tid -> Bap.Std.var -> Bap.Std.exp -> Bap.Std.Def.t
val lhs : Bap.Std.Def.t -> Bap.Std.var
val rhs : Bap.Std.Def.t -> Bap.Std.exp
val with_lhs : Bap.Std.Def.t -> Bap.Std.var -> Bap.Std.Def.t
val with_rhs : Bap.Std.Def.t -> Bap.Std.exp -> Bap.Std.Def.t
val map_exp :
Bap.Std.Def.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Def.t
val substitute :
Bap.Std.Def.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Def.t
val free_vars : Bap.Std.Def.t -> Bap.Std.Var.Set.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Blk.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Jmp :
sig
type t = Bap.Std.jmp Bap.Std.term
val create :
?tid:Bap.Std.tid ->
?cond:Bap.Std.exp -> Bap.Std.jmp_kind -> Bap.Std.Jmp.t
val create_call :
?tid:Bap.Std.tid ->
?cond:Bap.Std.exp -> Bap.Std.call -> Bap.Std.Jmp.t
val create_goto :
?tid:Bap.Std.tid ->
?cond:Bap.Std.exp -> Bap.Std.label -> Bap.Std.Jmp.t
val create_ret :
?tid:Bap.Std.tid ->
?cond:Bap.Std.exp -> Bap.Std.label -> Bap.Std.Jmp.t
val create_int :
?tid:Bap.Std.tid ->
?cond:Bap.Std.exp -> int -> Bap.Std.tid -> Bap.Std.Jmp.t
val kind : Bap.Std.Jmp.t -> Bap.Std.jmp_kind
val cond : Bap.Std.Jmp.t -> Bap.Std.exp
val exps : Bap.Std.Jmp.t -> Bap.Std.exp Bap.Std.seq
val free_vars : Bap.Std.Jmp.t -> Bap.Std.Var.Set.t
val map_exp :
Bap.Std.Jmp.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Jmp.t
val substitute :
Bap.Std.Jmp.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Jmp.t
val with_cond : Bap.Std.Jmp.t -> Bap.Std.exp -> Bap.Std.Jmp.t
val with_kind : Bap.Std.Jmp.t -> Bap.Std.jmp_kind -> Bap.Std.Jmp.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Def.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Phi :
sig
type t = Bap.Std.phi Bap.Std.term
val create :
?tid:Bap.Std.tid ->
Bap.Std.var -> Bap.Std.tid -> Bap.Std.exp -> Bap.Std.Phi.t
val of_list :
?tid:Bap.Std.tid ->
Bap.Std.var -> (Bap.Std.tid * Bap.Std.exp) list -> Bap.Std.Phi.t
val values :
Bap.Std.Phi.t -> (Bap.Std.tid * Bap.Std.exp) Bap.Std.seq
val free_vars : Bap.Std.Phi.t -> Bap.Std.Var.Set.t
val lhs : Bap.Std.Phi.t -> Bap.Std.var
val with_lhs : Bap.Std.Phi.t -> Bap.Std.var -> Bap.Std.Phi.t
val map_exp :
Bap.Std.Phi.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Phi.t
val substitute :
Bap.Std.Phi.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Phi.t
val update :
Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.exp -> Bap.Std.Phi.t
val select : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.exp option
val select_or_unknown : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.exp
val remove : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.Phi.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Jmp.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Arg :
sig
type t = Bap.Std.arg Bap.Std.term
val create :
?tid:Bap.Std.tid ->
?intent:Bap.Std.intent ->
Bap.Std.var -> Bap.Std.exp -> Bap.Std.Arg.t
val lhs : Bap.Std.Arg.t -> Bap.Std.var
val rhs : Bap.Std.Arg.t -> Bap.Std.exp
val intent : Bap.Std.Arg.t -> Bap.Std.intent option
val with_intent : Bap.Std.Arg.t -> Bap.Std.intent -> Bap.Std.Arg.t
val with_unknown_intent : Bap.Std.Arg.t -> Bap.Std.Arg.t
val warn_unused : unit Bap.Std.tag
val alloc_size : unit Bap.Std.tag
val format : string Bap.Std.tag
val nonnull : unit Bap.Std.tag
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Phi.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Call :
sig
type t = Bap.Std.call
val create :
?return:Bap.Std.label ->
target:Bap.Std.label -> unit -> Bap.Std.Call.t
val target : Bap.Std.Call.t -> Bap.Std.label
val return : Bap.Std.Call.t -> Bap.Std.label option
val with_target : Bap.Std.Call.t -> Bap.Std.label -> Bap.Std.Call.t
val with_return : Bap.Std.Call.t -> Bap.Std.label -> Bap.Std.Call.t
val with_noreturn : Bap.Std.Call.t -> Bap.Std.Call.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.call
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Arg.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Label :
sig
type t = Bap.Std.label
val create : unit -> Bap.Std.Label.t
val direct : Bap.Std.tid -> Bap.Std.Label.t
val indirect : Bap.Std.exp -> Bap.Std.Label.t
val change :
?direct:(Bap.Std.tid -> Bap.Std.tid) ->
?indirect:(Bap.Std.exp -> Bap.Std.exp) ->
Bap.Std.Label.t -> Bap.Std.Label.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Bap.Std.label
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Call.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
module Source :
sig
type 'a t = 'a Core_kernel.Std.Or_error.t Bap_future.Std.stream
type 'a source = 'a Bap.Std.Source.t
module Factory :
sig
module type S =
sig
type t
val list : unit -> string list
val find :
string ->
Bap.Std.Source.Factory.S.t Bap.Std.Source.source option
val register :
string ->
Bap.Std.Source.Factory.S.t Bap.Std.Source.source -> unit
end
module Make :
functor (T : Core_kernel.Std.T) ->
sig
type t = T.t
val list : unit -> Trie.String.Suffix.key list
val find : Trie.String.Suffix.key -> t source option
val register : Trie.String.Suffix.key -> t source -> unit
end
end
end
module Taint :
sig
type t = Bap.Std.tid
type set = Bap.Std.Tid.Set.t
val bin_set : set Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_set : set Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_set__ :
(int -> set) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_set : set Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_set : set Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_set : set Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_set : set Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_set : Core_kernel.Std.Bin_prot.Shape.t
val compare_set : set -> set -> int
val set_of_sexp : Sexplib.Sexp.t -> set
val sexp_of_set : set -> Sexplib.Sexp.t
type map = Bap.Std.Taint.set Bap.Std.Var.Map.t
val bin_map : map Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_map : map Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_map__ :
(int -> map) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_map : map Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_map : map Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_map : map Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_map : map Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_map : Core_kernel.Std.Bin_prot.Shape.t
val compare_map : map -> map -> int
val map_of_sexp : Sexplib.Sexp.t -> map
val sexp_of_map : map -> Sexplib.Sexp.t
val reg : Bap.Std.Taint.t Bap.Std.tag
val ptr : Bap.Std.Taint.t Bap.Std.tag
val regs : Bap.Std.Taint.map Bap.Std.tag
val ptrs : Bap.Std.Taint.map Bap.Std.tag
val merge :
Bap.Std.Taint.map -> Bap.Std.Taint.map -> Bap.Std.Taint.map
class context :
object ('a)
method all_taints : Bap.Std.Taint.set
method ptr_taints : Bap.Std.addr -> Bap.Std.Taint.set
method reg_taints : Bap.Std.Bil.result -> Bap.Std.Taint.set
method taint_ptr :
Bap.Std.addr -> Bap.Std.size -> Bap.Std.Taint.set -> 'a
method taint_reg :
Bap.Std.Bil.result -> Bap.Std.Taint.set -> 'a
end
module type S =
sig
type ('a, 'e) state
module Expi :
sig
type ('a, 'e) state = ('a, 'e) state
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop :
binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast :
cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract :
int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Expi.context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] propagator :
object
constraint 'a =
< all_taints : set; bindings : (var * Bil.result) seq;
create_storage : Bil.storage -> 'a * Bil.result;
create_undefined : 'a * Bil.result;
create_word : word -> 'a * Bil.result;
lookup : var -> Bil.result option;
ptr_taints : addr -> set;
reg_taints : Bil.result -> set;
taint_ptr : addr -> size -> set -> 'a;
taint_reg : Bil.result -> set -> 'a;
update : var -> Bil.result -> 'a; .. >
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
end
module Make :
functor (M : Monads.Std.Monad.State.S2) ->
sig
type ('a, 'e) state = ('a, 'e) M.t
module Expi :
sig
type ('a, 'e) state = ('a, 'e) M.t
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop :
binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast :
cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract :
int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let :
var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update :
var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Expi.context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat :
exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp ->
yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key ->
typ -> (Bil.result, 'a) M.t
method eval_unop :
unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] propagator :
object
constraint 'a =
< all_taints : set; bindings : (var * Bil.result) seq;
create_storage : Bil.storage -> 'a * Bil.result;
create_undefined : 'a * Bil.result;
create_word : word -> 'a * Bil.result;
lookup : var -> Bil.result option;
ptr_taints : addr -> set;
reg_taints : Bil.result -> set;
taint_ptr : addr -> size -> set -> 'a;
taint_reg : Bil.result -> set -> 'a;
update : var -> Bil.result -> 'a; .. >
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let :
var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp ->
exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
end
type ('a, 'e) state = ('a, 'e) Biri.state
module Expi :
sig
type ('a, 'e) state = ('a, 'e) Biri.state
type 'a u = (unit, 'a) state
type 'a r = (Bil.result, 'a) state
module M : sig type ('a, 'e) t = ('a, 'e) state end
module Eval :
sig
class type ['a, 'r] semantics =
['a, 'r] Eval.T2(M).semantics
class type virtual ['a, 'r, 's] domain =
['a, 'r, 's] Eval.T2(M).domain
class type virtual ['a, 'r, 's] eff =
['a, 'r, 's] Eval.T2(M).eff
class virtual ['a, 'r, 's] t :
object
method division_by_zero : unit -> ('r, 'a) state
method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
method eval_concat : exp -> exp -> ('r, 'a) M.t
method eval_exp : exp -> ('r, 'a) M.t
method eval_extract : int -> int -> exp -> ('r, 'a) M.t
method eval_int : word -> ('r, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
method eval_let : var -> exp -> exp -> ('r, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
method eval_unop : unop -> exp -> ('r, 'a) M.t
method eval_var : var -> ('r, 'a) M.t
method virtual load : 's -> addr -> ('r, 'a) M.t
method virtual lookup : var -> ('r, 'a) M.t
method private virtual storage_of_value :
'r -> ('s option, 'a) M.t
method virtual store :
's -> addr -> word -> ('r, 'a) M.t
method type_error : type_error -> ('r, 'a) state
method private virtual undefined : ('r, 'a) M.t
method virtual update : var -> 'r -> (unit, 'a) M.t
method private virtual value_of_word :
word -> ('r, 'a) M.t
method private virtual word_of_value :
'r -> (word option, 'a) M.t
end
end
class ['a] t :
object
constraint 'a = #Expi.context
method division_by_zero : unit -> 'a r
method empty : Bil.storage
method eval_binop :
binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast :
cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract :
int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp ->
addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a r
method lookup : var -> 'a r
method store : Bil.storage -> addr -> word -> 'a r
method type_error : type_error -> 'a r
method undefined_addr : addr -> 'a r
method undefined_var : var -> 'a r
method update : var -> Bil.result -> 'a u
end
end
class ['a] propagator :
object
constraint 'a =
< all_taints : set; bindings : (var * Bil.result) seq;
create_storage : Bil.storage -> 'a * Bil.result;
create_undefined : 'a * Bil.result;
create_word : word -> 'a * Bil.result;
lookup : var -> Bil.result option;
ptr_taints : addr -> set; reg_taints : Bil.result -> set;
taint_ptr : addr -> size -> set -> 'a;
taint_reg : Bil.result -> set -> 'a;
update : var -> Bil.result -> 'a; .. >
method division_by_zero : unit -> 'a Expi.r
method empty : Bil.storage
method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
method eval_exp : exp -> (Bil.result, 'a) M.t
method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
method eval_int : word -> (Bil.result, 'a) M.t
method eval_ite :
cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
method eval_load :
mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_store :
mem:exp ->
addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
method eval_unknown :
Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
method eval_var : var -> (Bil.result, 'a) M.t
method load : Bil.storage -> addr -> 'a Expi.r
method lookup : var -> 'a Expi.r
method store : Bil.storage -> addr -> word -> 'a Expi.r
method type_error : type_error -> 'a Expi.r
method undefined_addr : addr -> 'a Expi.r
method undefined_var : var -> 'a Expi.r
method update : var -> Bil.result -> 'a Expi.u
end
val pp_set : Bap.Std.Taint.set Regular.Std.printer
val pp_map : Bap.Std.Taint.map Regular.Std.printer
module Map :
sig
type t = map
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = map
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(map, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : map -> 'a -> 'a t
val of_alist :
(map * 'a) list ->
[ `Duplicate_key of map | `Ok of 'a t ]
val of_alist_or_error :
(map * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (map * 'a) list -> 'a t
val of_alist_multi : (map * 'a) list -> 'a list t
val of_alist_fold :
(map * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(map * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(map * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(map * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> map * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:map -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of map | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(map, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
map Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:map -> data:'a -> 'a t
val add_multi :
'a list t -> key:map -> data:'a -> 'a list t
val remove_multi : 'a list t -> map -> 'a list t
val change :
'a t -> map -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> map -> f:('a option -> 'a) -> 'a t
val find : 'a t -> map -> 'a option
val find_exn : 'a t -> map -> 'a
val remove : 'a t -> map -> 'a t
val mem : 'a t -> map -> bool
val iter_keys : 'a t -> f:(map -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:map -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:map ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:map -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:map -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:map -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:map ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(map -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:map -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:map -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:map -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:map -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> map list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (map * 'a) list
val validate :
name:(map -> Trie.String.Suffix.key) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:map ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(map, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (map * 'a) option
val min_elt_exn : 'a t -> map * 'a
val max_elt : 'a t -> (map * 'a) option
val max_elt_exn : 'a t -> map * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:map -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:map -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:map -> data:'a -> bool) -> int
val split :
'a t -> map -> 'a t * (map * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:map Base__.Maybe_bound.t ->
upper_bound:map Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:map ->
max:map ->
init:'b -> f:(key:map -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:map -> max:map -> (map * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> map -> (map * 'a) option
val nth : 'a t -> int -> (map * 'a) option
val nth_exn : 'a t -> int -> map * 'a
val rank : 'a t -> map -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:map ->
?keys_less_or_equal_to:map ->
'a t -> (map * 'a) Base__.Sequence.t
val obs :
map Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
map Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> map end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(map, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : map -> 'a -> 'a t
val of_alist :
(map * 'a) list ->
[ `Duplicate_key of map | `Ok of 'a t ]
val of_alist_or_error :
(map * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (map * 'a) list -> 'a t
val of_alist_multi : (map * 'a) list -> 'a list t
val of_alist_fold :
(map * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(map * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(map * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (map * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> map * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:map -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of map | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(map, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
map Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:map -> data:'a -> 'a t
val add_multi :
'a list t -> key:map -> data:'a -> 'a list t
val remove_multi : 'a list t -> map -> 'a list t
val change :
'a t -> map -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> map -> f:('a option -> 'a) -> 'a t
val find : 'a t -> map -> 'a option
val find_exn : 'a t -> map -> 'a
val remove : 'a t -> map -> 'a t
val mem : 'a t -> map -> bool
val iter_keys : 'a t -> f:(map -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:map -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:map ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:map -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:map -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:map -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:map ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(map -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:map -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:map -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:map -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:map -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> map list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (map * 'a) list
val validate :
name:(map -> Trie.String.Suffix.key) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:map ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(map, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (map * 'a) option
val min_elt_exn : 'a t -> map * 'a
val max_elt : 'a t -> (map * 'a) option
val max_elt_exn : 'a t -> map * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:map -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:map -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:map -> data:'a -> bool) -> int
val split : 'a t -> map -> 'a t * (map * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:map Base__.Maybe_bound.t ->
upper_bound:map Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:map ->
max:map ->
init:'b -> f:(key:map -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:map -> max:map -> (map * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> map -> (map * 'a) option
val nth : 'a t -> int -> (map * 'a) option
val nth_exn : 'a t -> int -> map * 'a
val rank : 'a t -> map -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:map ->
?keys_less_or_equal_to:map ->
'a t -> (map * 'a) Base__.Sequence.t
val obs :
map Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
map Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> map end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : map Bin_prot.Type_class.t
val bin_read_t : map Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> map)
Bin_prot.Read.reader
val bin_reader_t :
map Bin_prot.Type_class.reader
val bin_size_t : map Bin_prot.Size.sizer
val bin_write_t : map Bin_prot.Write.writer
val bin_writer_t :
map Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
map -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = map
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(map, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(map -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> map -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> map -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(map -> bool) -> bool
val for_all : t -> f:(map -> bool) -> bool
val count : t -> f:(map -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(map -> 'sum) -> 'sum
val find : t -> f:(map -> bool) -> map option
val find_map : t -> f:(map -> 'a option) -> 'a option
val to_list : t -> map list
val to_array : t -> map array
val invariants : t -> bool
val mem : t -> map -> bool
val add : t -> map -> t
val remove : t -> map -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (map, map) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
map ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(map -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of map * map
| `Left of map
| `Right of map ] -> unit) ->
unit
val filter : t -> f:(map -> bool) -> t
val partition_tf : t -> f:(map -> bool) -> t * t
val elements : t -> map list
val min_elt : t -> map option
val min_elt_exn : t -> map
val max_elt : t -> map option
val max_elt_exn : t -> map
val choose : t -> map option
val choose_exn : t -> map
val split : t -> map -> t * map option * t
val group_by :
t -> equiv:(map -> map -> bool) -> t list
val find_exn : t -> f:(map -> bool) -> map
val find_index : t -> int -> map option
val nth : t -> int -> map option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:map ->
?less_or_equal_to:map -> t -> map Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:map ->
?less_or_equal_to:map ->
t ->
t ->
(map, map)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(map -> 'data) ->
(map, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
map Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
map Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : map -> t
val union_list : t list -> t
val of_list : map list -> t
val of_array : map array -> t
val of_sorted_array : map array -> t Base__.Or_error.t
val of_sorted_array_unchecked : map array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> map) -> t
val stable_dedup_list : map list -> map list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> map) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> map option) -> t
val of_tree : t -> t
val of_hash_set : map Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(map, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(map, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
map Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> map
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (map, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(map -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> map -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> map -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(map -> bool) -> bool
val for_all : t -> f:(map -> bool) -> bool
val count : t -> f:(map -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(map -> 'sum) -> 'sum
val find : t -> f:(map -> bool) -> map option
val find_map : t -> f:(map -> 'a option) -> 'a option
val to_list : t -> map list
val to_array : t -> map array
val invariants : t -> bool
val mem : t -> map -> bool
val add : t -> map -> t
val remove : t -> map -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (map, map) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
map ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(map -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of map * map | `Left of map | `Right of map ] ->
unit) ->
unit
val filter : t -> f:(map -> bool) -> t
val partition_tf : t -> f:(map -> bool) -> t * t
val elements : t -> map list
val min_elt : t -> map option
val min_elt_exn : t -> map
val max_elt : t -> map option
val max_elt_exn : t -> map
val choose : t -> map option
val choose_exn : t -> map
val split : t -> map -> t * map option * t
val group_by : t -> equiv:(map -> map -> bool) -> t list
val find_exn : t -> f:(map -> bool) -> map
val find_index : t -> int -> map option
val nth : t -> int -> map option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:map ->
?less_or_equal_to:map -> t -> map Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:map ->
?less_or_equal_to:map ->
t ->
t ->
(map, map)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(map -> 'data) ->
(map, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
map Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
map Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : map -> t
val union_list : t list -> t
val of_list : map list -> t
val of_array : map array -> t
val of_sorted_array : map array -> t Base__.Or_error.t
val of_sorted_array_unchecked : map array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> map) -> t
val stable_dedup_list : map list -> map list
val map : ('a, 'b) Base.Set.t -> f:('a -> map) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> map option) -> t
val of_tree : Tree.t -> t
val of_hash_set : map Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(map, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(map, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
map Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> map end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : map Bin_prot.Type_class.t
val bin_read_t : map Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> map)
Bin_prot.Read.reader
val bin_reader_t :
map Bin_prot.Type_class.reader
val bin_size_t : map Bin_prot.Size.sizer
val bin_write_t : map Bin_prot.Write.writer
val bin_writer_t :
map Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
map -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Label.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> Trie.String.Suffix.key) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = map
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> map -> Core_kernel__.Import.bool
val lookup : 'a t -> map -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> map -> 'a
val enqueue :
'a t -> map -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> map -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> map -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> map -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (map * 'a) Core_kernel__.Import.option
val keys : 'a t -> map Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (map * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> map * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> map -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> map -> Core_kernel__.Import.unit
val replace : 'a t -> map -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> map -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:map -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:map -> data:'a -> 'b) -> 'b
end
type info =
Trie.String.Suffix.key *
[ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t ->
(unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
end
end
type 'a source = 'a Bap.Std.Source.t
module Symbolizer :
sig
type t = Bap.Std.symbolizer
val create :
(Bap.Std.addr -> string option) -> Bap.Std.Symbolizer.t
val of_blocks :
(string * Bap.Std.addr * Bap.Std.addr) Bap.Std.seq ->
Bap.Std.Symbolizer.t
val resolve : Bap.Std.Symbolizer.t -> Bap.Std.addr -> string
val chain : Bap.Std.Symbolizer.t list -> Bap.Std.Symbolizer.t
val empty : Bap.Std.Symbolizer.t
module Factory :
sig
type t = Bap.Std.symbolizer
val list : unit -> Trie.String.Suffix.key list
val find : Trie.String.Suffix.key -> t Source.source option
val register :
Trie.String.Suffix.key -> t Source.source -> unit
end
end
module Rooter :
sig
type t = Bap.Std.rooter
val create : Bap.Std.addr Bap.Std.seq -> Bap.Std.Rooter.t
val of_image : Bap.Std.image -> Bap.Std.Rooter.t
val of_blocks :
(string * Bap.Std.addr * Bap.Std.addr) Bap.Std.seq ->
Bap.Std.Rooter.t
val roots : Bap.Std.Rooter.t -> Bap.Std.addr Bap.Std.seq
val union :
Bap.Std.Rooter.t -> Bap.Std.Rooter.t -> Bap.Std.Rooter.t
module Factory :
sig
type t = Bap.Std.rooter
val list : unit -> Trie.String.Suffix.key list
val find : Trie.String.Suffix.key -> t Source.source option
val register :
Trie.String.Suffix.key -> t Source.source -> unit
end
end
module Brancher :
sig
type t = Bap.Std.brancher
type dest = Bap.Std.addr option * Bap.Std.edge
val dest_of_sexp : Sexplib.Sexp.t -> dest
val sexp_of_dest : dest -> Sexplib.Sexp.t
type dests = Bap.Std.Brancher.dest list
val dests_of_sexp : Sexplib.Sexp.t -> dests
val sexp_of_dests : dests -> Sexplib.Sexp.t
val create :
(Bap.Std.mem ->
Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Brancher.dests) ->
Bap.Std.Brancher.t
val of_bil : Bap.Std.arch -> Bap.Std.Brancher.t
val resolve :
Bap.Std.Brancher.t ->
Bap.Std.mem ->
Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Brancher.dests
module Factory :
sig
type t = Bap.Std.brancher
val list : unit -> Trie.String.Suffix.key list
val find : Trie.String.Suffix.key -> t Source.source option
val register :
Trie.String.Suffix.key -> t Source.source -> unit
end
end
module Reconstructor :
sig
type t = Bap.Std.reconstructor
val create :
(Bap.Std.cfg -> Bap.Std.symtab) -> Bap.Std.Reconstructor.t
val default :
(Bap.Std.word -> string) ->
Bap.Std.word list -> Bap.Std.Reconstructor.t
val of_blocks :
(string * Bap.Std.addr * Bap.Std.addr) Bap.Std.seq ->
Bap.Std.Reconstructor.t
val run : Bap.Std.Reconstructor.t -> Bap.Std.cfg -> Bap.Std.symtab
module Factory :
sig
type t = Bap.Std.reconstructor
val list : unit -> Trie.String.Suffix.key list
val find : Trie.String.Suffix.key -> t Source.source option
val register :
Trie.String.Suffix.key -> t Source.source -> unit
end
end
module Event :
sig
type t = ..
type event = Bap.Std.Event.t = ..
val stream : Bap.Std.Event.t Bap_future.Std.stream
val send : Bap.Std.Event.t -> unit
val register_printer : (Bap.Std.Event.t -> string option) -> unit
module Log :
sig
type level = Debug | Info | Warning | Error
type info = {
level : Bap.Std.Event.Log.level;
section : string;
message : string;
}
type event += Message of Bap.Std.Event.Log.info
val message :
Bap.Std.Event.Log.level ->
section:string ->
('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
type event +=
Progress of { task : string; note : string option;
stage : int option; total : int option;
}
val progress :
?note:string -> ?stage:int -> ?total:int -> string -> unit
end
val to_string : t -> Trie.String.Suffix.key
val str : unit -> t -> Trie.String.Suffix.key
val pps : unit -> t -> Trie.String.Suffix.key
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq : Format.formatter -> t Seq.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
type event = Bap.Std.Event.t = ..
type project
module Project :
sig
type t = Bap.Std.project
type input
type info =
Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
Trie.String.Suffix.key option
val version : Trie.String.Suffix.key
val size_in_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> int
val of_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
val to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
val load :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t -> unit
val save :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> t -> unit
val print :
?ver:Trie.String.Suffix.key ->
?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader -> unit
val add_writer :
?desc:Trie.String.Suffix.key ->
ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer :
?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
val with_printer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> (unit -> 'a) -> 'a
val find_reader :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.reader option
val find_writer :
?ver:Trie.String.Suffix.key ->
Trie.String.Suffix.key -> t Regular.Std.writer option
val create :
?disassembler:string ->
?brancher:Bap.Std.brancher Bap.Std.source ->
?symbolizer:Bap.Std.symbolizer Bap.Std.source ->
?rooter:Bap.Std.rooter Bap.Std.source ->
?reconstructor:Bap.Std.reconstructor Bap.Std.source ->
Bap.Std.Project.input ->
Bap.Std.Project.t Core_kernel.Std.Or_error.t
val arch : Bap.Std.Project.t -> Bap.Std.arch
val disasm : Bap.Std.Project.t -> Bap.Std.disasm
val program : Bap.Std.Project.t -> Bap.Std.program Bap.Std.term
val with_program :
Bap.Std.Project.t ->
Bap.Std.program Bap.Std.term -> Bap.Std.Project.t
val symbols : Bap.Std.Project.t -> Bap.Std.symtab
val with_symbols :
Bap.Std.Project.t -> Bap.Std.symtab -> Bap.Std.Project.t
val storage : Bap.Std.Project.t -> Bap.Std.dict
val with_storage :
Bap.Std.Project.t -> Bap.Std.dict -> Bap.Std.Project.t
val memory : Bap.Std.Project.t -> Bap.Std.value Bap.Std.memmap
val tag_memory :
Bap.Std.Project.t ->
Bap.Std.mem -> 'a Bap.Std.tag -> 'a -> Bap.Std.Project.t
val substitute :
Bap.Std.Project.t ->
Bap.Std.mem -> string Bap.Std.tag -> string -> Bap.Std.Project.t
val with_memory :
Bap.Std.Project.t ->
Bap.Std.value Bap.Std.memmap -> Bap.Std.Project.t
val set :
Bap.Std.Project.t -> 'a Bap.Std.tag -> 'a -> Bap.Std.Project.t
val get : Bap.Std.Project.t -> 'a Bap.Std.tag -> 'a option
val has : Bap.Std.Project.t -> 'a Bap.Std.tag -> bool
val del : Bap.Std.Project.t -> 'a Bap.Std.tag -> Bap.Std.Project.t
module Info :
sig
val file : string Bap_future.Std.stream
val arch : Bap.Std.arch Bap_future.Std.stream
val data : Bap.Std.value Bap.Std.memmap Bap_future.Std.stream
val code : Bap.Std.value Bap.Std.memmap Bap_future.Std.stream
val cfg : Bap.Std.cfg Bap_future.Std.stream
val symtab : Bap.Std.symtab Bap_future.Std.stream
val program :
Bap.Std.program Bap.Std.term Bap_future.Std.stream
val spec : Ogre.Doc.t Bap_future.Std.stream
end
module Input :
sig
type t = Bap.Std.Project.input
val file :
?loader:string -> filename:string -> Bap.Std.Project.Input.t
val binary :
?base:Bap.Std.addr ->
Bap.Std.arch -> filename:string -> Bap.Std.Project.Input.t
val create :
?finish:(Bap.Std.project -> Bap.Std.project) ->
Bap.Std.arch ->
string ->
code:Bap.Std.value Bap.Std.memmap ->
data:Bap.Std.value Bap.Std.memmap -> Bap.Std.Project.Input.t
val register_loader :
string -> (string -> Bap.Std.Project.Input.t) -> unit
val available_loaders : unit -> string list
end
type pass
val register_pass :
?autorun:bool ->
?runonce:bool ->
?deps:string list ->
?name:string -> (Bap.Std.Project.t -> Bap.Std.Project.t) -> unit
val register_pass' :
?autorun:bool ->
?runonce:bool ->
?deps:string list ->
?name:string -> (Bap.Std.Project.t -> unit) -> unit
val passes : unit -> Bap.Std.Project.pass list
val find_pass : string -> Bap.Std.Project.pass option
type second = float
module Pass :
sig
type t = Bap.Std.Project.pass
type error =
Unsat_dep of Bap.Std.Project.pass * string
| Runtime_error of Bap.Std.Project.pass * exn
val sexp_of_error : error -> Sexplib.Sexp.t
exception Failed of Bap.Std.Project.Pass.error
val run :
Bap.Std.Project.Pass.t ->
Bap.Std.project ->
(Bap.Std.project, Bap.Std.Project.Pass.error)
Core_kernel.Std.Result.t
val run_exn :
Bap.Std.Project.Pass.t -> Bap.Std.project -> Bap.Std.project
val name : Bap.Std.Project.Pass.t -> string
val autorun : Bap.Std.Project.Pass.t -> bool
end
val restore_state : Bap.Std.Project.t -> unit
end
module Self :
functor () ->
sig
val name : string
val version : string
val doc : string
val argv : string array
val debug :
('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
val info :
('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
val warning :
('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
val error :
('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
val debug_formatter : Format.formatter
val info_formatter : Format.formatter
val warning_formatter : Format.formatter
val error_formatter : Format.formatter
val report_progress :
?task:string ->
?note:string -> ?stage:int -> ?total:int -> unit -> unit
module Config :
sig
val version : string
val datadir : string
val libdir : string
val confdir : string
type 'a param
type 'a parser = string -> [ `Error of string | `Ok of 'a ]
type 'a converter
val converter :
'a Bap.Std.Self.Config.parser ->
'a Regular.Std.printer ->
'a -> 'a Bap.Std.Self.Config.converter
val deprecated : string
val param :
'a Bap.Std.Self.Config.converter ->
?deprecated:string ->
?default:'a ->
?as_flag:'a ->
?docv:string ->
?doc:string ->
?synonyms:string list ->
string -> 'a Bap.Std.Self.Config.param
val param_all :
'a Bap.Std.Self.Config.converter ->
?deprecated:string ->
?default:'a list ->
?as_flag:'a ->
?docv:string ->
?doc:string ->
?synonyms:string list ->
string -> 'a list Bap.Std.Self.Config.param
val flag :
?deprecated:string ->
?docv:string ->
?doc:string ->
?synonyms:string list ->
string -> bool Bap.Std.Self.Config.param
val determined :
'a Bap.Std.Self.Config.param -> 'a Bap_future.Std.future
type reader = {
get : 'a. 'a Bap.Std.Self.Config.param -> 'a;
}
val when_ready : (Bap.Std.Self.Config.reader -> unit) -> unit
type manpage_block =
[ `I of string * string
| `Noblank
| `P of string
| `Pre of string
| `S of string ]
val manpage : Bap.Std.Self.Config.manpage_block list -> unit
val bool : bool Bap.Std.Self.Config.converter
val char : char Bap.Std.Self.Config.converter
val int : int Bap.Std.Self.Config.converter
val nativeint : nativeint Bap.Std.Self.Config.converter
val int32 : int32 Bap.Std.Self.Config.converter
val int64 : int64 Bap.Std.Self.Config.converter
val float : float Bap.Std.Self.Config.converter
val string : string Bap.Std.Self.Config.converter
val enum :
(string * 'a) list -> 'a Bap.Std.Self.Config.converter
val doc_enum : ?quoted:bool -> (string * 'a) list -> string
val file : string Bap.Std.Self.Config.converter
val dir : string Bap.Std.Self.Config.converter
val non_dir_file : string Bap.Std.Self.Config.converter
val list :
?sep:char ->
'a Bap.Std.Self.Config.converter ->
'a list Bap.Std.Self.Config.converter
val array :
?sep:char ->
'a Bap.Std.Self.Config.converter ->
'a array Bap.Std.Self.Config.converter
val pair :
?sep:char ->
'a Bap.Std.Self.Config.converter ->
'b Bap.Std.Self.Config.converter ->
('a * 'b) Bap.Std.Self.Config.converter
val t2 :
?sep:char ->
'a Bap.Std.Self.Config.converter ->
'b Bap.Std.Self.Config.converter ->
('a * 'b) Bap.Std.Self.Config.converter
val t3 :
?sep:char ->
'a Bap.Std.Self.Config.converter ->
'b Bap.Std.Self.Config.converter ->
'c Bap.Std.Self.Config.converter ->
('a * 'b * 'c) Bap.Std.Self.Config.converter
val t4 :
?sep:char ->
'a Bap.Std.Self.Config.converter ->
'b Bap.Std.Self.Config.converter ->
'c Bap.Std.Self.Config.converter ->
'd Bap.Std.Self.Config.converter ->
('a * 'b * 'c * 'd) Bap.Std.Self.Config.converter
val some :
?none:string ->
'a Bap.Std.Self.Config.converter ->
'a option Bap.Std.Self.Config.converter
end
end
module Log : sig val start : ?logdir:string -> unit -> unit end
module Monad :
sig
module type Basic = Core_kernel.Std.Monad.Basic
module type Basic2 = Core_kernel.Std.Monad.Basic2
module type Infix = Core_kernel.Std.Monad.Infix
module type Infix2 = Core_kernel.Std.Monad.Infix2
module type S = Core_kernel.Std.Monad.S
module type S2 = Core_kernel.Std.Monad.S2
module Make :
functor (M : Basic) ->
sig
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
module Monad_infix :
sig
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
end
val bind : 'a M.t -> f:('a -> 'b M.t) -> 'b M.t
val return : 'a -> 'a M.t
val map : 'a M.t -> f:('a -> 'b) -> 'b M.t
val join : 'a M.t M.t -> 'a M.t
val ignore_m : 'a M.t -> unit M.t
val all : 'a M.t list -> 'a list M.t
val all_ignore : unit M.t list -> unit M.t
module Let_syntax :
sig
val return : 'a -> 'a M.t
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
module Let_syntax :
sig
val return : 'a -> 'a M.t
val bind : 'a M.t -> f:('a -> 'b M.t) -> 'b M.t
val map : 'a M.t -> f:('a -> 'b) -> 'b M.t
val both : 'a M.t -> 'b M.t -> ('a * 'b) M.t
module Open_on_rhs : sig end
end
end
end
module Make2 :
functor (M : Basic2) ->
sig
val ( >>= ) :
('a, 'e) M.t -> ('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) : ('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) M.t
val ( >>= ) :
('a, 'e) M.t -> ('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) : ('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) M.t
val bind :
('a, 'e) M.t ->
f:('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val map :
('a, 'e) M.t -> f:('a -> 'b) -> ('b, 'e) M.t
val both :
('a, 'e) M.t -> ('b, 'e) M.t -> ('a * 'b, 'e) M.t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) M.t -> ('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) : ('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
end
val bind :
('a, 'e) M.t -> f:('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val return : 'a -> ('a, 'b) M.t
val map : ('a, 'e) M.t -> f:('a -> 'b) -> ('b, 'e) M.t
val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
val ignore_m : ('a, 'e) M.t -> (unit, 'e) M.t
val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
val all_ignore : (unit, 'e) M.t list -> (unit, 'e) M.t
end
module State :
sig
module type S =
sig
type ('a, 's) t
type 'a result
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
val put : 's -> (unit, 's) t
val get : unit -> ('s, 's) t
val gets : ('s -> 'r) -> ('r, 's) t
val update : ('s -> 's) -> (unit, 's) t
val modify : ('a, 's) t -> ('s -> 's) -> ('a, 's) t
val run : ('a, 's) t -> 's -> ('a * 's) result
val eval : ('a, 's) t -> 's -> 'a result
val exec : ('a, 's) t -> 's -> 's result
end
type ('a, 'e) t = ('a, 'e) Taint.state
type 'a result = 'a
val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
val put : 's -> (unit, 's) t
val get : unit -> ('s, 's) t
val gets : ('s -> 'r) -> ('r, 's) t
val update : ('s -> 's) -> (unit, 's) t
val modify : ('a, 's) t -> ('s -> 's) -> ('a, 's) t
val run : ('a, 's) t -> 's -> 'a * 's
val eval : ('a, 's) t -> 's -> 'a
val exec : ('a, 's) t -> 's -> 's
end
module T :
sig
module Option :
sig
module Make :
functor (M : S) ->
sig
type 'a t = 'a option M.t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_ignore : unit t list -> unit t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
end
module Make2 :
functor (M : S2) ->
sig
type ('a, 'b) t = ('a option, 'b) M.t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
end
end
module Or_error :
sig
module Make :
functor (M : S) ->
sig
type 'a t = 'a Memory.With_error.m M.t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_ignore : unit t list -> unit t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
end
module Make2 :
functor (M : S2) ->
sig
type ('a, 'b) t = ('a Memory.With_error.m, 'b) M.t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
end
end
module Result :
sig
module Make :
functor (M : S) ->
sig
type ('a, 'e) t =
('a, 'e) Core_kernel.Std.Result.t M.t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
end
end
module State :
sig
module Make :
functor (M : S) ->
sig
type ('a, 's) t
type 'a result = 'a M.t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
val put : 's -> (unit, 's) t
val get : unit -> ('s, 's) t
val gets : ('s -> 'r) -> ('r, 's) t
val update : ('s -> 's) -> (unit, 's) t
val modify : ('a, 's) t -> ('s -> 's) -> ('a, 's) t
val run : ('a, 's) t -> 's -> ('a * 's) result
val eval : ('a, 's) t -> 's -> 'a result
val exec : ('a, 's) t -> 's -> 's result
end
end
end
end
end
end